src/SketchPlugin/SketchPlugin_Validators.cpp

   1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "SketchPlugin_Validators.h"
  21
  22 #include "SketchPlugin_Arc.h"
  23 #include "SketchPlugin_Circle.h"
  24 #include "SketchPlugin_ConstraintCoincidence.h"
  25 #include "SketchPlugin_ConstraintDistance.h"
  26 #include "SketchPlugin_ConstraintRigid.h"
  27 #include "SketchPlugin_ConstraintTangent.h"
  28 #include "SketchPlugin_Fillet.h"
  29 #include "SketchPlugin_Line.h"
  30 #include "SketchPlugin_MacroArc.h"
  31 #include "SketchPlugin_MacroCircle.h"
  32 #include "SketchPlugin_MultiRotation.h"
  33 #include "SketchPlugin_Point.h"
  34 #include "SketchPlugin_Sketch.h"
  35 #include "SketchPlugin_Trim.h"
  36 #include "SketchPlugin_Tools.h"
  37
  38 #include "SketcherPrs_Tools.h"
  39
  40 #include <Events_InfoMessage.h>
  41
  42 #include <ModelAPI_Data.h>
  43 #include <ModelAPI_Validator.h>
  44 #include <ModelAPI_AttributeDouble.h>
  45 #include <ModelAPI_AttributeInteger.h>
  46 #include <ModelAPI_AttributeRefAttr.h>
  47 #include <ModelAPI_AttributeRefList.h>
  48 #include <ModelAPI_AttributeSelectionList.h>
  49 #include <ModelAPI_AttributeString.h>
  50 #include <ModelAPI_Session.h>
  51 #include <ModelAPI_Tools.h>
  52 #include <ModelAPI_ResultConstruction.h>
  53
  54 #include <ModelGeomAlgo_Point2D.h>
  55 #include <ModelGeomAlgo_Shape.h>
  56
  57 #include <GeomAlgoAPI_EdgeBuilder.h>
  58 #include <GeomAlgoAPI_ShapeTools.h>
  59
  60 #include <GeomAPI_Circ.h>
  61 #include <GeomAPI_Dir2d.h>
  62 #include <GeomAPI_Lin.h>
  63 #include <GeomAPI_Edge.h>
  64 #include <GeomAPI_Vertex.h>
  65 #include <GeomDataAPI_Point2D.h>
  66
  67 #include <algorithm>
  68 #include <cmath>
  69
  70 const double tolerance = 1.e-7;
  71
  72 bool SketchPlugin_DistanceAttrValidator::isValid(const AttributePtr& theAttribute,
  73                                                  const std::list<std::string>& theArguments,
  74                                                  Events_InfoMessage& theError) const
  75 {
  76   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
  77     theError = "The attribute with the %1 type is not processed";
  78     theError.arg(theAttribute->attributeType());
  79     return false;
  80   }
  81
  82   // there is a check whether the feature contains a point and a linear edge or two point values
  83   std::string aParamA = theArguments.front();
  84   SessionPtr aMgr = ModelAPI_Session::get();
  85   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
  86
  87   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>
  88                                                                       (theAttribute);
  89   bool isObject = aRefAttr->isObject();
  90   if (!isObject) {
  91     // an attribute is a point. A point value is valid always for the distance
  92     return true;
  93   } else {
  94     // 1. check whether the references object is a linear
  95     ObjectPtr anObject = aRefAttr->object();
  96
  97     const ModelAPI_AttributeValidator* aShapeValidator =
  98       dynamic_cast<const ModelAPI_AttributeValidator*>(
  99       aFactory->validator("GeomValidators_ShapeType"));
 100     std::list<std::string> anArguments;
 101     anArguments.push_back("circle");
 102     Events_InfoMessage aCircleError;
 103     bool aShapeValid = aShapeValidator->isValid(aRefAttr, anArguments, aCircleError);
 104     // the circle line is not a valid case
 105     if (aShapeValid) {
 106       theError = "Circle can not be used in distance constraint";
 107       return false;
 108     }
 109
 110     anArguments.clear();
 111     anArguments.push_back("line");
 112     Events_InfoMessage aLineError;
 113     aShapeValid = aShapeValidator->isValid(aRefAttr, anArguments, aLineError);
 114     // if the attribute value is not a line, that means it is a vertex. A vertex is always valid
 115     if (aShapeValid) {
 116       FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 117       // If it is a line then we have to check that first attribute id not a line
 118       std::shared_ptr<SketchPlugin_Feature> aSFeature =
 119         std::dynamic_pointer_cast<SketchPlugin_Feature>(theAttribute->owner());
 120       SketchPlugin_Sketch* aSketch = aSFeature->sketch();
 121       std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(aSketch);
 122       std::shared_ptr<GeomDataAPI_Point2D> aPoint = SketcherPrs_Tools::getFeaturePoint(
 123         aFeature->data(), aParamA, aPlane);
 124       if (!aPoint.get()) {
 125         theError = "One of parameters of distance constraint should be a point";
 126         return false;
 127       }
 128     }
 129   }
 130   return true;
 131 }
 132
 133 bool SketchPlugin_TangentAttrValidator::isValid(const AttributePtr& theAttribute,
 134                                                 const std::list<std::string>& theArguments,
 135                                                 Events_InfoMessage& theError) const
 136 {
 137   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 138     theError = "The attribute with the %1 type is not processed";
 139     theError.arg(theAttribute->attributeType());
 140     return false;
 141   }
 142
 143   // there is a check whether the feature contains a point and a linear edge or two point values
 144   std::string aParamA = theArguments.front();
 145   SessionPtr aMgr = ModelAPI_Session::get();
 146   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
 147
 148   FeaturePtr anAttributeFeature =
 149     std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 150   AttributeRefAttrPtr aRefAttr =
 151     std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 152
 153   bool isObject = aRefAttr->isObject();
 154   ObjectPtr anObject = aRefAttr->object();
 155   if (isObject && anObject.get()) {
 156     FeaturePtr aRefFea = ModelAPI_Feature::feature(anObject);
 157
 158     AttributeRefAttrPtr aOtherAttr = anAttributeFeature->data()->refattr(aParamA);
 159     ObjectPtr aOtherObject = aOtherAttr->object();
 160     FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject);
 161     if (!aOtherFea)
 162       return true;
 163
 164     if (aRefFea->getKind() == SketchPlugin_Line::ID()) {
 165       if (aOtherFea->getKind() != SketchPlugin_Arc::ID() &&
 166           aOtherFea->getKind() != SketchPlugin_Circle::ID()) {
 167         theError = "It refers to a %1, but %2 is neither an %3 nor %4";
 168         theError.arg(SketchPlugin_Line::ID()).arg(aParamA)
 169             .arg(SketchPlugin_Arc::ID()).arg(SketchPlugin_Circle::ID());
 170         return false;
 171       }
 172     }
 173     else if (aRefFea->getKind() == SketchPlugin_Arc::ID() ||
 174              aRefFea->getKind() == SketchPlugin_Circle::ID()) {
 175       if (aOtherFea->getKind() != SketchPlugin_Line::ID() &&
 176           aOtherFea->getKind() != SketchPlugin_Arc::ID() &&
 177           aOtherFea->getKind() != SketchPlugin_Circle::ID()) {
 178         theError = "It refers to an %1, but %2 is not a %3 or an %4 or a %5";
 179         theError.arg(SketchPlugin_Arc::ID()).arg(aParamA)
 180             .arg(SketchPlugin_Line::ID()).arg(SketchPlugin_Arc::ID())
 181             .arg(SketchPlugin_Circle::ID());
 182         return false;
 183       }
 184     }
 185     else {
 186       theError = "It refers to %1, but should refer to %2 or %3 or %4";
 187       theError.arg(aRefFea->getKind()).arg(SketchPlugin_Line::ID())
 188           .arg(SketchPlugin_Arc::ID()).arg(SketchPlugin_Circle::ID());
 189       return false;
 190     }
 191     return true;
 192   }
 193   else {
 194     theError = "It uses an empty object";
 195     return false;
 196   }
 197
 198   return true;
 199 }
 200
 201 bool SketchPlugin_PerpendicularAttrValidator::isValid(const AttributePtr& theAttribute,
 202                                                       const std::list<std::string>& theArguments,
 203                                                       Events_InfoMessage& theError) const
 204 {
 205   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 206     theError = "The attribute with the %1 type is not processed";
 207     theError.arg(theAttribute->attributeType());
 208     return false;
 209   }
 210
 211   std::string aParamA = theArguments.front();
 212   SessionPtr aMgr = ModelAPI_Session::get();
 213   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
 214
 215   FeaturePtr anOwner = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 216   AttributeRefAttrPtr aRefAttr =
 217       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 218
 219   bool isObject = aRefAttr->isObject();
 220   ObjectPtr anObject = aRefAttr->object();
 221   if (isObject && anObject.get()) {
 222     FeaturePtr aRefFea = ModelAPI_Feature::feature(anObject);
 223
 224     AttributeRefAttrPtr aOtherAttr = anOwner->refattr(aParamA);
 225     ObjectPtr aOtherObject = aOtherAttr->object();
 226     FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject);
 227     if (!aOtherFea)
 228       return true;
 229
 230     // at least one feature should be a line
 231     if (aRefFea->getKind() != SketchPlugin_Line::ID() &&
 232         aOtherFea->getKind() != SketchPlugin_Line::ID()) {
 233       theError = "At least one feature should be a line";
 234       return false;
 235     }
 236   }
 237   else {
 238     theError = "It uses an empty object";
 239     return false;
 240   }
 241
 242   return true;
 243 }
 244
 245 bool SketchPlugin_NotFixedValidator::isValid(const AttributePtr& theAttribute,
 246                                              const std::list<std::string>& theArguments,
 247                                              Events_InfoMessage& theError) const
 248 {
 249   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 250     theError = "The attribute with the %1 type is not processed";
 251     theError.arg(theAttribute->attributeType());
 252     return false;
 253   }
 254
 255   std::shared_ptr<SketchPlugin_Feature> aFeature =
 256       std::dynamic_pointer_cast<SketchPlugin_Feature>(theAttribute->owner());
 257   if (!aFeature)
 258     return true;
 259
 260   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 261
 262   SketchPlugin_Sketch* aSketch = aFeature->sketch();
 263   int aNbFeatures = aSketch->numberOfSubs();
 264   for (int anInd = 0; anInd < aNbFeatures; anInd++) {
 265     FeaturePtr aSubFeature = aSketch->subFeature(anInd);
 266     if (aSubFeature->getKind() != SketchPlugin_ConstraintRigid::ID() || aSubFeature == aFeature)
 267       continue;
 268     AttributeRefAttrPtr aRAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 269         aSubFeature->attribute(SketchPlugin_ConstraintRigid::ENTITY_A()));
 270     if (aRefAttr->isObject()) {
 271       if (aRefAttr->object() == aRAttr->object()) {
 272         ObjectPtr anObject = aRefAttr->object();
 273         std::string aName = anObject.get() ? anObject->data()->name() : "";
 274         theError = "The object %1 has been already fixed.";
 275         theError.arg(aName);
 276         return false;
 277       }
 278     }
 279     else if (aRefAttr->attr() == aRAttr->attr()) {
 280       AttributePtr anAttribute = aRefAttr->attr();
 281       std::string aName = anAttribute.get() ? anAttribute->id() : "";
 282       theError = "The attribute %1 has been already fixed.";
 283       theError.arg(aName);
 284       return false;
 285     }
 286   }
 287   return true;
 288 }
 289
 290 bool SketchPlugin_EqualAttrValidator::isValid(const AttributePtr& theAttribute,
 291                                               const std::list<std::string>& theArguments,
 292                                               Events_InfoMessage& theError) const
 293 {
 294   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 295     theError = "The attribute with the %1 type is not processed";
 296     theError.arg(theAttribute->attributeType());
 297     return false;
 298   }
 299
 300   std::string aParamA = theArguments.front();
 301   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 302   AttributeRefAttrPtr aRefAttr[2];
 303   aRefAttr[0] = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 304   aRefAttr[1] = aFeature->data()->refattr(aParamA);
 305
 306   if (!aRefAttr[0]->isObject() || !aRefAttr[1]->isObject()) {
 307     theError = "Attributes can not be used in equal constraint";
 308     return false;
 309   }
 310
 311   std::string aType[2];
 312   std::list<std::string> anArguments;
 313   for (int i = 0; i < 2; i++) {
 314     ObjectPtr anObject = aRefAttr[i]->object();
 315     if (!anObject.get()) {
 316       theError = "An empty object is used.";
 317       return false;
 318     }
 319
 320     aFeature = ModelAPI_Feature::feature(anObject);
 321     if (!aFeature.get()) {
 322       theError = "An empty feature is used.";
 323       return false;
 324     }
 325
 326     aType[i] = aFeature->getKind();
 327     if (aFeature->getKind() != SketchPlugin_Line::ID() &&
 328         aFeature->getKind() != SketchPlugin_Circle::ID() &&
 329         aFeature->getKind() != SketchPlugin_Arc::ID()) {
 330       theError = "The %1 feature kind of attribute is wrong. It should be %2 or %3 or %4";
 331       theError.arg(aFeature->getKind()).arg(SketchPlugin_Line::ID())
 332           .arg(SketchPlugin_Circle::ID()).arg(SketchPlugin_Arc::ID());
 333       // wrong type of attribute
 334       return false;
 335     }
 336   }
 337
 338   if ((aType[0] == SketchPlugin_Line::ID() || aType[1] == SketchPlugin_Line::ID()) &&
 339       aType[0] != aType[1]) {
 340     theError = "Feature with kinds %1 and %2 can not be equal.";
 341     theError.arg(aType[0]).arg(aType[1]);
 342     return false;
 343   }
 344   return true;
 345 }
 346
 347 bool SketchPlugin_MirrorAttrValidator::isValid(const AttributePtr& theAttribute,
 348                                                const std::list<std::string>& theArguments,
 349                                                Events_InfoMessage& theError) const
 350 {
 351   if (theAttribute->attributeType() != ModelAPI_AttributeRefList::typeId()) {
 352     theError = "The attribute with the %1 type is not processed";
 353     theError.arg(theAttribute->attributeType());
 354     return false;
 355   }
 356
 357   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 358   AttributeRefListPtr aSelAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(theAttribute);
 359
 360   AttributeRefListPtr aRefListOfMirrored = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
 361       aFeature->attribute(SketchPlugin_Constraint::ENTITY_C()));
 362   std::list<ObjectPtr> aMirroredObjects = aRefListOfMirrored->list();
 363
 364   for(int anInd = 0; anInd < aSelAttr->size(); anInd++) {
 365     ObjectPtr aSelObject = aSelAttr->object(anInd);
 366     std::string aName = aSelObject.get() ? aSelObject->data()->name() : "";
 367     std::list<ObjectPtr>::iterator aMirIter = aMirroredObjects.begin();
 368     for (; aMirIter != aMirroredObjects.end(); aMirIter++)
 369       if (aSelObject == *aMirIter) {
 370         theError = "The object %1 is a result of mirror";
 371         theError.arg(aName);
 372         return false;
 373       }
 374   }
 375   return true;
 376 }
 377
 378 bool SketchPlugin_CoincidenceAttrValidator::isValid(const AttributePtr& theAttribute,
 379                                                     const std::list<std::string>& theArguments,
 380                                                     Events_InfoMessage& theError) const
 381 {
 382   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 383     theError = "The attribute with the %1 type is not processed";
 384     theError.arg(theAttribute->attributeType());
 385     return false;
 386   }
 387
 388   // there is a check whether the feature contains a point and a linear edge or two point values
 389   std::string aParamA = theArguments.front();
 390   SessionPtr aMgr = ModelAPI_Session::get();
 391   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
 392
 393   FeaturePtr aConstraint = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 394   AttributeRefAttrPtr aRefAttrA = aConstraint->data()->refattr(aParamA);
 395   if (!aRefAttrA) {
 396     theError = "The %1 attribute should be %2";
 397     theError.arg(aParamA).arg(ModelAPI_AttributeRefAttr::typeId());
 398     return false;
 399   }
 400
 401   AttributeRefAttrPtr aRefAttrB =
 402     std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 403
 404   // first attribute is a point, it may coincide with any object
 405   if (!aRefAttrA->isObject())
 406     return true;
 407   else {
 408     ObjectPtr anObject = aRefAttrA->object();
 409     if (!anObject.get()) {
 410       theError = "%1 attribute has an empty object";
 411       theError.arg(aParamA);
 412       return false;
 413     }
 414     FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttrA->object());
 415     if (!aFeature.get()) {
 416       theError = "%1 attribute has an empty feature";
 417       theError.arg(aParamA);
 418       return false;
 419     }
 420
 421     if (aFeature->getKind() == SketchPlugin_Point::ID())
 422       return true;
 423   }
 424
 425   // second attribute is a point, it may coincide with any object
 426   if (!aRefAttrB->isObject())
 427     return true;
 428   else {
 429     FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttrB->object());
 430     if (!aFeature) {
 431       theError = "%1 attribute has an empty object";
 432       theError.arg(theAttribute->id());
 433       return false;
 434     }
 435     if (aFeature->getKind() == SketchPlugin_Point::ID())
 436       return true;
 437   }
 438   theError = "There is no an attribute filled by a point";
 439   return false;
 440 }
 441
 442
 443 bool SketchPlugin_CopyValidator::isValid(const AttributePtr& theAttribute,
 444                                          const std::list<std::string>& theArguments,
 445                                          Events_InfoMessage& theError) const
 446 {
 447   if (theAttribute->attributeType() != ModelAPI_AttributeRefList::typeId()) {
 448     theError = "The attribute with the %1 type is not processed";
 449     theError.arg(theAttribute->attributeType());
 450     return false;
 451   }
 452
 453   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 454   AttributeRefListPtr aSelAttr =
 455     std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(theAttribute);
 456
 457   AttributeRefListPtr aRefListOfInitial = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
 458       aFeature->attribute(SketchPlugin_Constraint::ENTITY_A()));
 459   AttributeRefListPtr aRefListOfCopied = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
 460       aFeature->attribute(SketchPlugin_Constraint::ENTITY_B()));
 461   std::list<ObjectPtr> anInitialObjects = aRefListOfInitial->list();
 462   std::list<ObjectPtr> aCopiedObjects = aRefListOfCopied->list();
 463
 464   std::list<ObjectPtr>::iterator anObjIter;
 465   for(int anInd = 0; anInd < aSelAttr->size(); anInd++) {
 466     ObjectPtr aSelObject = aSelAttr->object(anInd);
 467     anObjIter = anInitialObjects.begin();
 468     for (; anObjIter != anInitialObjects.end(); anObjIter++)
 469       if (aSelObject == *anObjIter)
 470         break;
 471     if (anObjIter != anInitialObjects.end())
 472       continue;
 473     anObjIter = aCopiedObjects.begin();
 474     for (; anObjIter != aCopiedObjects.end(); anObjIter++)
 475       if (aSelObject == *anObjIter) {
 476         std::string aName = aSelObject.get() ? aSelObject->data()->name() : "";
 477         theError = "The object %1 is a result of copy";
 478         theError.arg(aName);
 479         return false;
 480       }
 481   }
 482   return true;
 483 }
 484
 485 bool SketchPlugin_SolverErrorValidator::isValid(
 486   const std::shared_ptr<ModelAPI_Feature>& theFeature,
 487   const std::list<std::string>& theArguments,
 488   Events_InfoMessage& theError) const
 489 {
 490   AttributeStringPtr aAttributeString = theFeature->string(SketchPlugin_Sketch::SOLVER_ERROR());
 491
 492   if (!aAttributeString->value().empty()) {
 493     theError = aAttributeString->value();
 494     return false;
 495   }
 496
 497   return true;
 498 }
 499
 500 bool SketchPlugin_SolverErrorValidator::isNotObligatory(std::string theFeature,
 501                                                         std::string theAttribute)
 502 {
 503   return true;
 504 }
 505
 506 static bool hasSameTangentFeature(const std::set<AttributePtr>& theRefsList,
 507                                   const FeaturePtr theFeature)
 508 {
 509   for(std::set<AttributePtr>::const_iterator
 510       anIt = theRefsList.cbegin(); anIt != theRefsList.cend(); ++anIt) {
 511     std::shared_ptr<ModelAPI_Attribute> aAttr = (*anIt);
 512     FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
 513     if (!aFeature)
 514       continue;
 515     if (aFeature->getKind() == SketchPlugin_ConstraintTangent::ID()) {
 516       AttributeRefAttrPtr anAttrRefA = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 517         aFeature->attribute(SketchPlugin_ConstraintTangent::ENTITY_A()));
 518       AttributeRefAttrPtr anAttrRefB = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 519         aFeature->attribute(SketchPlugin_ConstraintTangent::ENTITY_B()));
 520       if(anAttrRefA.get()) {
 521         ResultPtr aResA = std::dynamic_pointer_cast<ModelAPI_Result>(anAttrRefA->object());
 522         if(aResA.get()) {
 523           DocumentPtr aDoc = aResA->document();
 524           if(aDoc.get()) {
 525             FeaturePtr aFeatureA = aDoc->feature(aResA);
 526             if(aFeatureA.get() && aFeatureA == theFeature) {
 527               return true;
 528             }
 529           }
 530         }
 531       }
 532       if(anAttrRefB.get()) {
 533         ResultPtr aResB = std::dynamic_pointer_cast<ModelAPI_Result>(anAttrRefB->object());
 534         if(aResB.get()) {
 535           DocumentPtr aDoc = aResB->document();
 536           if(aDoc.get()) {
 537             FeaturePtr aFeatureB = aDoc->feature(aResB);
 538             if(aFeatureB.get() && aFeatureB == theFeature) {
 539               return true;
 540             }
 541           }
 542         }
 543       }
 544     }
 545   }
 546   return false;
 547 }
 548
 549 static bool isPointPointCoincidence(const FeaturePtr& theCoincidence)
 550 {
 551   AttributeRefAttrPtr aRefAttr[2] = {
 552       theCoincidence->refattr(SketchPlugin_Constraint::ENTITY_A()),
 553       theCoincidence->refattr(SketchPlugin_Constraint::ENTITY_B())
 554   };
 555
 556   bool arePoints = true;
 557   for (int i = 0; i < 2 && arePoints; ++i) {
 558     if (aRefAttr[i]->isObject()) {
 559       FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr[i]->object());
 560       arePoints = aFeature.get() && aFeature->getKind() == SketchPlugin_Point::ID();
 561     } else
 562       arePoints = aRefAttr[i]->attr().get() != NULL;
 563   }
 564   return arePoints;
 565 }
 566
 567 bool SketchPlugin_FilletVertexValidator::isValid(const AttributePtr& theAttribute,
 568                                                  const std::list<std::string>& theArguments,
 569                                                  Events_InfoMessage& theError) const
 570 {
 571   AttributeRefAttrPtr aPointRefAttr =
 572     std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 573   if(!aPointRefAttr.get()) {
 574     theError = "Error: Point not selected.";
 575     return false;
 576   }
 577
 578   AttributePtr aPointAttribute = aPointRefAttr->attr();
 579   if (!aPointAttribute.get()) {
 580     theError = "Error: Bad point selected.";
 581     return false;
 582   }
 583   std::shared_ptr<GeomAPI_Pnt2d> aSelectedPnt =
 584     std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aPointAttribute)->pnt();
 585
 586   // Obtain constraint coincidence for the fillet point.
 587   const std::set<AttributePtr>& aRefsList = aPointAttribute->owner()->data()->refsToMe();
 588   FeaturePtr aConstraintCoincidence;
 589   for(std::set<AttributePtr>::const_iterator anIt = aRefsList.cbegin();
 590       anIt != aRefsList.cend(); ++anIt) {
 591     std::shared_ptr<ModelAPI_Attribute> aAttr = (*anIt);
 592     FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
 593     if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
 594       if (!isPointPointCoincidence(aConstrFeature))
 595         continue;
 596
 597       AttributeRefAttrPtr anAttrRefA = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 598         aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_A()));
 599       AttributeRefAttrPtr anAttrRefB = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 600         aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_B()));
 601
 602       AttributePtr anAttrA = anAttrRefA->attr();
 603       if(aPointAttribute == anAttrA) {
 604         aConstraintCoincidence = aConstrFeature;
 605         break;
 606       }
 607
 608       AttributePtr anAttrB = anAttrRefB->attr();
 609       if(aPointAttribute == anAttrB) {
 610         aConstraintCoincidence = aConstrFeature;
 611         break;
 612       }
 613     }
 614   }
 615
 616   if(!aConstraintCoincidence.get()) {
 617     theError = "Error: one of the selected point does not have coicidence.";
 618     return false;
 619   }
 620
 621   // Get coincides from constraint.
 622   std::set<FeaturePtr> aCoinsides;
 623   SketchPlugin_Tools::findCoincidences(aConstraintCoincidence,
 624                                         SketchPlugin_ConstraintCoincidence::ENTITY_A(),
 625                                         aCoinsides,
 626                                         true);
 627   SketchPlugin_Tools::findCoincidences(aConstraintCoincidence,
 628                                         SketchPlugin_ConstraintCoincidence::ENTITY_B(),
 629                                         aCoinsides,
 630                                         true);
 631
 632   // Remove points and external lines from set of coincides.
 633   std::set<FeaturePtr> aNewSetOfCoincides;
 634   for(std::set<FeaturePtr>::iterator anIt = aCoinsides.begin();
 635       anIt != aCoinsides.end(); ++anIt) {
 636     std::shared_ptr<SketchPlugin_SketchEntity> aSketchEntity =
 637       std::dynamic_pointer_cast<SketchPlugin_SketchEntity>(*anIt);
 638     if(aSketchEntity.get() && (aSketchEntity->isCopy() || aSketchEntity->isExternal())) {
 639       continue;
 640     }
 641     if((*anIt)->getKind() != SketchPlugin_Line::ID() &&
 642         (*anIt)->getKind() != SketchPlugin_Arc::ID()) {
 643           continue;
 644     }
 645     if((*anIt)->getKind() == SketchPlugin_Arc::ID()) {
 646       AttributePtr anArcCenter = (*anIt)->attribute(SketchPlugin_Arc::CENTER_ID());
 647       std::shared_ptr<GeomAPI_Pnt2d> anArcCenterPnt =
 648         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anArcCenter)->pnt();
 649       double aDistSelectedArcCenter = aSelectedPnt->distance(anArcCenterPnt);
 650       if(aDistSelectedArcCenter < tolerance) {
 651         continue;
 652       }
 653     }
 654     aNewSetOfCoincides.insert(*anIt);
 655   }
 656   aCoinsides = aNewSetOfCoincides;
 657
 658   // If we still have more than two coincides remove auxilary entities from set of coincides.
 659   if(aCoinsides.size() > 2) {
 660     aNewSetOfCoincides.clear();
 661     for(std::set<FeaturePtr>::iterator anIt = aCoinsides.begin();
 662         anIt != aCoinsides.end(); ++anIt) {
 663       if(!(*anIt)->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->value()) {
 664         aNewSetOfCoincides.insert(*anIt);
 665       }
 666     }
 667     aCoinsides = aNewSetOfCoincides;
 668   }
 669
 670   if(aCoinsides.size() != 2) {
 671     theError = "Error: One of the selected points does not have two suitable edges for fillet.";
 672     return false;
 673   }
 674
 675   // Check that selected edges don't have tangent constraint.
 676   std::set<FeaturePtr>::iterator anIt = aCoinsides.begin();
 677   FeaturePtr aFirstFeature = *anIt++;
 678   FeaturePtr aSecondFeature = *anIt;
 679   const std::set<AttributePtr>& aFirstFeatureRefsList = aFirstFeature->data()->refsToMe();
 680   if(hasSameTangentFeature(aFirstFeatureRefsList, aSecondFeature)) {
 681     theError = "Error: Edges in selected point has tangent constraint.";
 682     return false;
 683   }
 684
 685   std::list<ResultPtr> aFirstResults = aFirstFeature->results();
 686   for(std::list<ResultPtr>::iterator aResIt = aFirstResults.begin();
 687       aResIt != aFirstResults.end(); ++aResIt) {
 688     ResultPtr aRes = *aResIt;
 689     const std::set<AttributePtr>& aResRefsList = aRes->data()->refsToMe();
 690     if(hasSameTangentFeature(aResRefsList, aSecondFeature)) {
 691       theError = "Error: Edges in selected point has tangent constraint.";
 692       return false;
 693     }
 694   }
 695
 696   // Check the features are not tangent
 697   std::shared_ptr<GeomAPI_Shape> aFirstShape = aFirstFeature->lastResult()->shape();
 698   std::shared_ptr<GeomAPI_Shape> aSecondShape = aSecondFeature->lastResult()->shape();
 699   if (!aFirstShape || !aFirstShape->isEdge() ||
 700       !aSecondShape || !aSecondShape->isEdge()) {
 701     theError = "Error: At least on of the features is not an edge";
 702     return false;
 703   }
 704
 705   std::shared_ptr<GeomAPI_Edge> anEdge1 = std::dynamic_pointer_cast<GeomAPI_Edge>(aFirstShape);
 706   std::shared_ptr<GeomAPI_Edge> anEdge2 = std::dynamic_pointer_cast<GeomAPI_Edge>(aSecondShape);
 707
 708   static const double TOL = 1.e-7;
 709   if (anEdge1->isLine() && anEdge2->isLine()) {
 710     // Check that lines not collinear
 711     std::shared_ptr<GeomAPI_Dir> aDir1 = anEdge1->line()->direction();
 712     std::shared_ptr<GeomAPI_Dir> aDir2 = anEdge2->line()->direction();
 713     double aCross = aDir1->cross(aDir2)->squareModulus();
 714     if (aCross < TOL * TOL)
 715       return false;
 716   } else if (anEdge1->isArc() && anEdge2->isArc()) {
 717     // check the circles are not tangent
 718     std::shared_ptr<GeomAPI_Circ> aCirc1 = anEdge1->circle();
 719     std::shared_ptr<GeomAPI_Circ> aCirc2 = anEdge2->circle();
 720     double aDistCC = aCirc1->center()->distance(aCirc2->center());
 721     double aRadSum = aCirc1->radius() + aCirc2->radius();
 722     double aRadDiff = fabs(aCirc1->radius() - aCirc2->radius());
 723     if (fabs(aDistCC - aRadSum) < TOL || fabs(aDistCC - aRadDiff) < TOL)
 724       return false;
 725   } else {
 726     // check whether line and arc are tangent
 727     std::shared_ptr<GeomAPI_Circ> aCirc;
 728     std::shared_ptr<GeomAPI_Lin> aLine;
 729     if (anEdge1->isLine()) {
 730       aLine = anEdge1->line();
 731       aCirc = anEdge2->circle();
 732     } else {
 733       aCirc = anEdge1->circle();
 734       aLine = anEdge2->line();
 735     }
 736
 737     double aDistCL = aLine->distance(aCirc->center());
 738     if (fabs(aDistCL - aCirc->radius()) < TOL)
 739       return false;
 740   }
 741
 742   return true;
 743 }
 744
 745 bool SketchPlugin_MiddlePointAttrValidator::isValid(const AttributePtr& theAttribute,
 746                                                     const std::list<std::string>& theArguments,
 747                                                     Events_InfoMessage& theError) const
 748 {
 749   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 750     theError = "The attribute with the %1 type is not processed";
 751     theError.arg(theAttribute->attributeType());
 752     return false;
 753   }
 754
 755   // there is a check whether the feature contains a point and a linear edge or two point values
 756   std::string aParamA = theArguments.front();
 757   SessionPtr aMgr = ModelAPI_Session::get();
 758   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
 759
 760   FeaturePtr anAttributeFeature =
 761     std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 762   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 763   AttributeRefAttrPtr anOtherAttr = anAttributeFeature->data()->refattr(aParamA);
 764
 765   AttributeRefAttrPtr aRefAttrs[2] = {aRefAttr, anOtherAttr};
 766   int aNbPoints = 0;
 767   int aNbLines = 0;
 768   for (int i = 0; i < 2; ++i) {
 769     if (!aRefAttrs[i]->isObject())
 770       ++aNbPoints;
 771     else {
 772       FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttrs[i]->object());
 773       if (!aFeature) {
 774         if (aNbPoints + aNbLines != 0)
 775           return true;
 776         else continue;
 777       }
 778
 779       if (aFeature->getKind() == SketchPlugin_Point::ID())
 780         ++aNbPoints;
 781       else if (aFeature->getKind() == SketchPlugin_Line::ID() ||
 782                aFeature->getKind() == SketchPlugin_Arc::ID())
 783         ++aNbLines;
 784     }
 785   }
 786
 787   if (aNbPoints != 1 || aNbLines != 1) {
 788     theError = "Middle point constraint allows points and lines only";
 789     return false;
 790   }
 791   return true;
 792 }
 793
 794 bool SketchPlugin_ArcTangentPointValidator::isValid(const AttributePtr& theAttribute,
 795                                                     const std::list<std::string>& /*theArguments*/,
 796                                                     Events_InfoMessage& theError) const
 797 {
 798   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 799     theError = "The attribute with the %1 type is not processed";
 800     theError.arg(theAttribute->attributeType());
 801     return false;
 802   }
 803   FeaturePtr anOwner = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 804   AttributeStringPtr anArcTypeAttr = anOwner->string(SketchPlugin_MacroArc::ARC_TYPE());
 805   if (anArcTypeAttr && anArcTypeAttr->value() != SketchPlugin_MacroArc::ARC_TYPE_BY_TANGENT_EDGE())
 806     return true; // not applicable for non-tangent arcs
 807
 808   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 809   AttributePtr anAttr = aRefAttr->attr();
 810   if (!anAttr) {
 811     theError = "The attribute %1 should be a point";
 812     theError.arg(theAttribute->id());
 813     return false;
 814   }
 815
 816   FeaturePtr anAttrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anAttr->owner());
 817   const std::string& aFeatureType = anAttrFeature->getKind();
 818   if (aFeatureType == SketchPlugin_Arc::ID()) {
 819     // selected point should not be a center of arc
 820     const std::string& aPntId = anAttr->id();
 821     if (aPntId != SketchPlugin_Arc::START_ID() && aPntId != SketchPlugin_Arc::END_ID()) {
 822       theError = "The attribute %1 is not supported";
 823       theError.arg(aPntId);
 824       return false;
 825     }
 826   }
 827   else if (aFeatureType == SketchPlugin_Line::ID()) {
 828     // selected point should be bound point of line
 829     const std::string& aPntId = anAttr->id();
 830     if (aPntId != SketchPlugin_Line::START_ID() && aPntId != SketchPlugin_Line::END_ID()) {
 831       theError = "The attribute %1 is not supported";
 832       theError.arg(aPntId);
 833       return false;
 834     }
 835   }
 836   else {
 837     theError = "Unable to build tangent arc on %1";
 838     theError.arg(anAttrFeature->getKind());
 839     return false;
 840   }
 841
 842   return true;
 843 }
 844
 845 bool SketchPlugin_ArcTransversalPointValidator::isValid(
 846     const AttributePtr& theAttribute,
 847     const std::list<std::string>& /*theArguments*/,
 848     Events_InfoMessage& theError) const
 849 {
 850   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 851     theError = "The attribute with the %1 type is not processed";
 852     theError.arg(theAttribute->attributeType());
 853     return false;
 854   }
 855   FeaturePtr anOwner = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 856   AttributeStringPtr anArcTypeAttr = anOwner->string(SketchPlugin_MacroArc::ARC_TYPE());
 857   if (anArcTypeAttr &&
 858       anArcTypeAttr->value() != SketchPlugin_MacroArc::ARC_TYPE_BY_TRANSVERSAL_LINE())
 859     return true; // not applicable for non-transversal arcs
 860
 861   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 862   AttributePtr anAttr = aRefAttr->attr();
 863   if (!anAttr) {
 864     theError = "The attribute %1 should be a point";
 865     theError.arg(theAttribute->id());
 866     return false;
 867   }
 868
 869   FeaturePtr anAttrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anAttr->owner());
 870   const std::string& aFeatureType = anAttrFeature->getKind();
 871   if (aFeatureType == SketchPlugin_Line::ID()) {
 872     // selected point should be bound point of line
 873     const std::string& aPntId = anAttr->id();
 874     if (aPntId != SketchPlugin_Line::START_ID() && aPntId != SketchPlugin_Line::END_ID()) {
 875       theError = "The attribute %1 is not supported";
 876       theError.arg(aPntId);
 877       return false;
 878     }
 879   }
 880   else {
 881     theError = "Unable to build transversal arc on %1";
 882     theError.arg(anAttrFeature->getKind());
 883     return false;
 884   }
 885
 886   return true;
 887 }
 888
 889 bool SketchPlugin_IntersectionValidator::isValid(const AttributePtr& theAttribute,
 890                                                  const std::list<std::string>& theArguments,
 891                                                  Events_InfoMessage& theError) const
 892 {
 893   if (theAttribute->attributeType() != ModelAPI_AttributeSelection::typeId()) {
 894     theError = "The attribute with the %1 type is not processed";
 895     theError.arg(theAttribute->attributeType());
 896     return false;
 897   }
 898   AttributeSelectionPtr anExternalAttr =
 899       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
 900   std::shared_ptr<GeomAPI_Edge> anEdge;
 901   if (anExternalAttr && anExternalAttr->value() && anExternalAttr->value()->isEdge()) {
 902     anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anExternalAttr->value()));
 903   } else if(anExternalAttr->context() && anExternalAttr->context()->shape() &&
 904             anExternalAttr->context()->shape()->isEdge()) {
 905     anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(anExternalAttr->context()->shape()));
 906   }
 907
 908   if (!anEdge) {
 909     theError = "The attribute %1 should be an edge";
 910     theError.arg(theAttribute->id());
 911     return false;
 912   }
 913
 914   // find a sketch
 915   std::shared_ptr<SketchPlugin_Sketch> aSketch;
 916   std::set<AttributePtr> aRefs = anExternalAttr->owner()->data()->refsToMe();
 917   std::set<AttributePtr>::const_iterator anIt = aRefs.begin();
 918   for (; anIt != aRefs.end(); ++anIt) {
 919     CompositeFeaturePtr aComp =
 920         std::dynamic_pointer_cast<ModelAPI_CompositeFeature>((*anIt)->owner());
 921     if (aComp && aComp->getKind() == SketchPlugin_Sketch::ID()) {
 922       aSketch = std::dynamic_pointer_cast<SketchPlugin_Sketch>(aComp);
 923       break;
 924     }
 925   }
 926   if (!aSketch) {
 927     theError = "There is no sketch referring to the current feature";
 928     return false;
 929   }
 930
 931   // check the edge is intersected with sketch plane
 932   std::shared_ptr<GeomAPI_Pln> aPlane = aSketch->plane();
 933
 934   std::list<GeomPointPtr> anIntersectionsPoints;
 935   anEdge->intersectWithPlane(aPlane, anIntersectionsPoints);
 936   if (anIntersectionsPoints.empty()) {
 937     theError = "The edge is not intersected with sketch plane";
 938     return false;
 939   }
 940   return true;
 941 }
 942
 943 bool SketchPlugin_SplitValidator::isValid(const AttributePtr& theAttribute,
 944                                           const std::list<std::string>& theArguments,
 945                                           Events_InfoMessage& theError) const
 946 {
 947   bool aValid = false;
 948
 949   if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) {
 950     theError = "The attribute with the %1 type is not processed";
 951     theError.arg(theAttribute->attributeType());
 952     return aValid;
 953   }
 954   AttributeReferencePtr aFeatureAttr =
 955             std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
 956
 957   ObjectPtr anAttrObject = aFeatureAttr->value();
 958   FeaturePtr anAttrFeature = ModelAPI_Feature::feature(anAttrObject);
 959   if (!anAttrFeature)
 960     return aValid;
 961
 962   std::string aKind = anAttrFeature->getKind();
 963   if (aKind == SketchPlugin_Line::ID() ||
 964       aKind == SketchPlugin_Arc::ID() ||
 965       aKind == SketchPlugin_Circle::ID()) {
 966
 967     std::set<ResultPtr> anEdgeShapes;
 968     ModelGeomAlgo_Shape::shapesOfType(anAttrFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
 969     if (anEdgeShapes.empty() || anEdgeShapes.size() > 1 /*there case has not existed yet*/)
 970       return aValid;
 971
 972     // coincidences to the feature
 973     std::set<std::shared_ptr<GeomDataAPI_Point2D> > aRefAttributes;
 974     ModelGeomAlgo_Point2D::getPointsOfReference(anAttrFeature,
 975                         SketchPlugin_ConstraintCoincidence::ID(),
 976                         aRefAttributes, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
 977
 978     GeomShapePtr anAttrShape = (*anEdgeShapes.begin())->shape();
 979     std::shared_ptr<SketchPlugin_Feature> aSFeature =
 980                                  std::dynamic_pointer_cast<SketchPlugin_Feature>(anAttrFeature);
 981     SketchPlugin_Sketch* aSketch = aSFeature->sketch();
 982
 983     std::shared_ptr<ModelAPI_Data> aData = aSketch->data();
 984     std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
 985         aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
 986     std::shared_ptr<GeomDataAPI_Dir> aX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 987         aData->attribute(SketchPlugin_Sketch::DIRX_ID()));
 988     std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 989         aData->attribute(SketchPlugin_Sketch::NORM_ID()));
 990     std::shared_ptr<GeomAPI_Dir> aDirY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
 991
 992     typedef std::map<std::shared_ptr<GeomAPI_Pnt>,
 993                      std::pair<std::list<std::shared_ptr<GeomDataAPI_Point2D> >,
 994                                std::list<std::shared_ptr<ModelAPI_Object> > > > PointToRefsMap;
 995     PointToRefsMap aPointsInfo;
 996
 997     ModelGeomAlgo_Point2D::getPointsInsideShape(anAttrShape, aRefAttributes, aC->pnt(),
 998                                                 aX->dir(), aDirY, aPointsInfo);
 999     int aCoincidentToFeature = (int)aPointsInfo.size();
1000     if (aKind == SketchPlugin_Circle::ID())
1001       aValid = aCoincidentToFeature >= 2;
1002     else
1003       aValid = aCoincidentToFeature >= 1;
1004   }
1005
1006   return aValid;
1007 }
1008
1009 bool SketchPlugin_TrimValidator::isValid(const AttributePtr& theAttribute,
1010                                          const std::list<std::string>& theArguments,
1011                                          Events_InfoMessage& theError) const
1012 {
1013   bool aValid = false;
1014
1015   if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) {
1016     theError = "The attribute with the %1 type is not processed";
1017     theError.arg(theAttribute->attributeType());
1018     return aValid;
1019   }
1020   AttributeReferencePtr aBaseObjectAttr =
1021             std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
1022
1023   std::shared_ptr<SketchPlugin_Feature> aTrimFeature =
1024                  std::dynamic_pointer_cast<SketchPlugin_Feature>(theAttribute->owner());
1025
1026   ObjectPtr aBaseObject = aBaseObjectAttr->value();
1027   if (!aBaseObject) {
1028     AttributePtr aPreviewAttr = aTrimFeature->attribute(SketchPlugin_Trim::PREVIEW_OBJECT());
1029     aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(aPreviewAttr);
1030     aBaseObject = aBaseObjectAttr->value();
1031   }
1032
1033   FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObject);
1034   if (!aBaseFeature)
1035     return aValid;
1036
1037   std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
1038                                  std::dynamic_pointer_cast<SketchPlugin_Feature>(aBaseFeature);
1039   if (!aSketchFeature.get() || aSketchFeature->isCopy())
1040     return aValid;
1041
1042   std::string aKind = aBaseFeature->getKind();
1043   if (aKind != SketchPlugin_Line::ID() &&
1044       aKind != SketchPlugin_Arc::ID() &&
1045       aKind != SketchPlugin_Circle::ID())
1046     return aValid;
1047
1048   // point on feature
1049   AttributePoint2DPtr aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
1050                        aTrimFeature->data()->attribute(SketchPlugin_Trim::PREVIEW_POINT()));
1051
1052   SketchPlugin_Sketch* aSketch = aTrimFeature->sketch();
1053
1054   std::shared_ptr<GeomAPI_Pnt2d> anAttributePnt2d = aPoint->pnt();
1055   std::shared_ptr<GeomAPI_Pnt> anAttributePnt = aSketch->to3D(anAttributePnt2d->x(),
1056                                                               anAttributePnt2d->y());
1057
1058   std::map<ObjectPtr, std::set<GeomShapePtr> > aCashedShapes;
1059   std::map<ObjectPtr, std::map<std::shared_ptr<GeomAPI_Pnt>,
1060            std::pair<std::list<std::shared_ptr<GeomDataAPI_Point2D> >,
1061                      std::list<std::shared_ptr<ModelAPI_Object> > > > > anObjectToPoints;
1062   SketchPlugin_Trim::fillObjectShapes(aBaseObject, aSketch->data()->owner(),
1063                                       aCashedShapes, anObjectToPoints);
1064   const std::set<GeomShapePtr>& aShapes = aCashedShapes[aBaseObject];
1065
1066   return aShapes.size() > 1;
1067 }
1068
1069 bool SketchPlugin_ProjectionValidator::isValid(const AttributePtr& theAttribute,
1070                                                const std::list<std::string>& theArguments,
1071                                                Events_InfoMessage& theError) const
1072 {
1073   if (theAttribute->attributeType() != ModelAPI_AttributeSelection::typeId()) {
1074     theError = "The attribute with the %1 type is not processed";
1075     theError.arg(theAttribute->attributeType());
1076     return false;
1077   }
1078
1079   AttributeSelectionPtr aFeatureAttr =
1080       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
1081   std::shared_ptr<GeomAPI_Edge> anEdge;
1082   std::shared_ptr<SketchPlugin_Feature> aSketchFeature;
1083   if (aFeatureAttr.get()) {
1084     GeomShapePtr aVal = aFeatureAttr->value();
1085     ResultPtr aRes = aFeatureAttr->context();
1086     if (aVal && aVal->isVertex())
1087       return true; // vertex is always could be projected
1088     if (aVal && aVal->isEdge()) {
1089       anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aFeatureAttr->value()));
1090     } else if(aRes && aRes->shape()) {
1091       if (aRes->shape()->isVertex())
1092         return true; // vertex is always could be projected
1093       else if (aRes->shape()->isEdge())
1094         anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aFeatureAttr->context()->shape()));
1095     }
1096
1097     // try to convert result to sketch feature
1098     if (aRes) {
1099       aSketchFeature =
1100         std::dynamic_pointer_cast<SketchPlugin_Feature>(ModelAPI_Feature::feature(aRes));
1101     }
1102   }
1103   if (!anEdge) {
1104     theError = "The attribute %1 should be an edge or vertex";
1105     theError.arg(theAttribute->id());
1106     return false;
1107   }
1108
1109   // find a sketch
1110   std::shared_ptr<SketchPlugin_Sketch> aSketch;
1111   std::set<AttributePtr> aRefs = theAttribute->owner()->data()->refsToMe();
1112   std::set<AttributePtr>::const_iterator anIt = aRefs.begin();
1113   for (; anIt != aRefs.end(); ++anIt) {
1114     CompositeFeaturePtr aComp =
1115         std::dynamic_pointer_cast<ModelAPI_CompositeFeature>((*anIt)->owner());
1116     if (aComp && aComp->getKind() == SketchPlugin_Sketch::ID()) {
1117       aSketch = std::dynamic_pointer_cast<SketchPlugin_Sketch>(aComp);
1118       break;
1119     }
1120   }
1121   if (!aSketch) {
1122     theError = "There is no sketch referring to the current feature";
1123     return false;
1124   }
1125   if (aSketchFeature && aSketch.get() == aSketchFeature->sketch()) {
1126     theError = "Unable to project feature from the same sketch";
1127     return false;
1128   }
1129
1130   std::shared_ptr<GeomAPI_Pln> aPlane = aSketch->plane();
1131   std::shared_ptr<GeomAPI_Dir> aNormal = aPlane->direction();
1132   std::shared_ptr<GeomAPI_Pnt> anOrigin = aPlane->location();
1133
1134   if (anEdge->isLine()) {
1135     std::shared_ptr<GeomAPI_Lin> aLine = anEdge->line();
1136     std::shared_ptr<GeomAPI_Dir> aLineDir = aLine->direction();
1137     double aDot = fabs(aNormal->dot(aLineDir));
1138     bool aValid = fabs(aDot - 1.0) >= tolerance * tolerance;
1139     if (!aValid)
1140       theError = "Error: Edge is already in the sketch plane.";
1141     return aValid;
1142   }
1143   else if (anEdge->isCircle() || anEdge->isArc()) {
1144     std::shared_ptr<GeomAPI_Circ> aCircle = anEdge->circle();
1145     std::shared_ptr<GeomAPI_Dir> aCircNormal = aCircle->normal();
1146     double aDot = fabs(aNormal->dot(aCircNormal));
1147     bool aValid = fabs(aDot - 1.0) < tolerance * tolerance;
1148     if (!aValid)
1149       theError.arg(anEdge->isCircle() ? "Error: Cirlce is already in the sketch plane."
1150                                       : "Error: Arc is already in the sketch plane.");
1151     return aValid;
1152   }
1153
1154   theError = "Error: Selected object is not line, circle or arc.";
1155   return false;
1156 }
1157
1158
1159 static std::set<FeaturePtr> common(const std::set<FeaturePtr>& theSet1,
1160                                    const std::set<FeaturePtr>& theSet2)
1161 {
1162   std::set<FeaturePtr> aCommon;
1163   if (theSet1.empty() || theSet2.empty())
1164     return aCommon;
1165
1166   std::set<FeaturePtr>::const_iterator anIt2 = theSet2.begin();
1167   for (; anIt2 != theSet2.end(); ++anIt2)
1168     if (theSet1.find(*anIt2) != theSet1.end())
1169       aCommon.insert(*anIt2);
1170   return aCommon;
1171 }
1172
1173 bool SketchPlugin_DifferentReferenceValidator::isValid(
1174     const AttributePtr& theAttribute,
1175     const std::list<std::string>& theArguments,
1176     Events_InfoMessage& theError) const
1177 {
1178   FeaturePtr anOwner = ModelAPI_Feature::feature(theAttribute->owner());
1179
1180   int aNbFeaturesReferred = 0;
1181   int aNbAttributesReferred = 0;
1182   std::set<FeaturePtr> aCommonReferredFeatures;
1183
1184   // find all features referred by attributes listed in theArguments
1185   std::list<std::string>::const_iterator anArgIt = theArguments.begin();
1186   for (; anArgIt != theArguments.end(); ++anArgIt) {
1187     AttributeRefAttrPtr aRefAttr = anOwner->refattr(*anArgIt);
1188     if (!aRefAttr)
1189       continue;
1190
1191     std::set<FeaturePtr> aCoincidentFeatures;
1192     if (aRefAttr->isObject()) {
1193       FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
1194       if (aFeature) {
1195         aCoincidentFeatures.insert(aFeature);
1196         aNbFeaturesReferred += 1;
1197       }
1198     } else {
1199       AttributePoint2DPtr aPoint =
1200           std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aRefAttr->attr());
1201       if (aPoint) {
1202         aCoincidentFeatures = SketchPlugin_Tools::findFeaturesCoincidentToPoint(aPoint);
1203         aNbAttributesReferred += 1;
1204       }
1205     }
1206
1207     if (aCommonReferredFeatures.empty())
1208       aCommonReferredFeatures = aCoincidentFeatures;
1209     else
1210       aCommonReferredFeatures = common(aCommonReferredFeatures, aCoincidentFeatures);
1211
1212     if (aCommonReferredFeatures.empty())
1213       return true;
1214   }
1215
1216   bool isOk = aNbFeaturesReferred < 1;
1217   if (aNbFeaturesReferred == 1) {
1218     if (aCommonReferredFeatures.size() == 1) {
1219       FeaturePtr aFeature = *aCommonReferredFeatures.begin();
1220       isOk = aNbAttributesReferred <= 1 ||
1221              aFeature->getKind() == SketchPlugin_Circle::ID() ||
1222              aFeature->getKind() == SketchPlugin_Arc::ID();
1223     } else
1224       isOk = false;
1225   }
1226
1227   if (!isOk)
1228     theError = "Attributes are referred to the same feature";
1229   return isOk;
1230 }
1231
1232 bool SketchPlugin_DifferentPointReferenceValidator::isValid(
1233     const AttributePtr& theAttribute,
1234     const std::list<std::string>& theArguments,
1235     Events_InfoMessage& theError) const
1236 {
1237   FeaturePtr anOwner = ModelAPI_Feature::feature(theAttribute->owner());
1238   std::set<AttributePoint2DPtr> aReferredCoincidentPoints;
1239
1240   // find all points referred by attributes listed in theArguments
1241   bool hasRefsToPoints = false;
1242   std::list<std::string>::const_iterator anArgIt = theArguments.begin();
1243   for (; anArgIt != theArguments.end(); ++anArgIt) {
1244     AttributeRefAttrPtr aRefAttr = anOwner->refattr(*anArgIt);
1245     if (!aRefAttr)
1246       continue;
1247
1248     if (!aRefAttr->isObject()) {
1249       AttributePoint2DPtr aPoint =
1250           std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aRefAttr->attr());
1251       if (aReferredCoincidentPoints.empty())
1252         aReferredCoincidentPoints = SketchPlugin_Tools::findPointsCoincidentToPoint(aPoint);
1253       else if (aReferredCoincidentPoints.find(aPoint) == aReferredCoincidentPoints.end())
1254         return true; // non-coincident point has been found
1255       else
1256         hasRefsToPoints = true;
1257     }
1258   }
1259
1260   if (hasRefsToPoints)
1261     theError = "Attributes are referred to the same point";
1262   return !hasRefsToPoints;
1263 }
1264
1265 bool SketchPlugin_CirclePassedPointValidator::isValid(
1266     const AttributePtr& theAttribute,
1267     const std::list<std::string>&,
1268     Events_InfoMessage& theError) const
1269 {
1270   static const std::string aErrorMessage(
1271       "Passed point refers to the same feature as a center point");
1272
1273   FeaturePtr anOwner = ModelAPI_Feature::feature(theAttribute->owner());
1274
1275   AttributeRefAttrPtr aCenterRef =
1276       anOwner->refattr(SketchPlugin_MacroCircle::CENTER_POINT_REF_ID());
1277   AttributeRefAttrPtr aPassedRef =
1278       anOwner->refattr(SketchPlugin_MacroCircle::PASSED_POINT_REF_ID());
1279
1280   if (!aPassedRef->isObject())
1281     return true;
1282
1283   FeaturePtr aPassedFeature = ModelAPI_Feature::feature(aPassedRef->object());
1284   if (!aPassedFeature)
1285     return true;
1286
1287   if (aCenterRef->isObject()) {
1288     if (aCenterRef->object() == aPassedRef->object()) {
1289       theError = aErrorMessage;
1290       return false;
1291     }
1292   } else {
1293     AttributePoint2DPtr aCenterPoint =
1294         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aCenterRef->attr());
1295     if (aCenterPoint) {
1296       std::set<FeaturePtr> aCoincidentFeatures =
1297           SketchPlugin_Tools::findFeaturesCoincidentToPoint(aCenterPoint);
1298       // check one of coincident features is a feature referred by passed point
1299       std::set<FeaturePtr>::const_iterator anIt = aCoincidentFeatures.begin();
1300       for(; anIt != aCoincidentFeatures.end(); ++anIt)
1301         if (*anIt == aPassedFeature) {
1302           theError = aErrorMessage;
1303           return false;
1304         }
1305     }
1306   }
1307   return true;
1308 }
1309
1310 bool SketchPlugin_ThirdPointValidator::isValid(
1311     const AttributePtr& theAttribute,
1312     const std::list<std::string>& theArguments,
1313     Events_InfoMessage& theError) const
1314 {
1315   FeaturePtr anOwner = ModelAPI_Feature::feature(theAttribute->owner());
1316   return arePointsNotOnLine(anOwner, theError) &&
1317          arePointsNotSeparated(anOwner, theArguments, theError);
1318 }
1319
1320 static std::shared_ptr<GeomAPI_Pnt2d> toPoint(const FeaturePtr& theMacroCircle,
1321                                               const std::string& thePointAttrName,
1322                                               const std::string& theRefPointAttrName)
1323 {
1324   AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
1325       theMacroCircle->attribute(thePointAttrName));
1326   AttributeRefAttrPtr aRefAttr = theMacroCircle->refattr(theRefPointAttrName);
1327
1328   std::shared_ptr<GeomAPI_Pnt2d> aPoint = aPointAttr->pnt();
1329   if (aRefAttr) {
1330     if (aRefAttr->isObject()) {
1331       // project a point onto selected feature
1332       std::shared_ptr<SketchPlugin_Feature> aFeature =
1333           std::dynamic_pointer_cast<SketchPlugin_Feature>(
1334           ModelAPI_Feature::feature(aRefAttr->object()));
1335       if (aFeature) {
1336         SketchPlugin_Sketch* aSketch = aFeature->sketch();
1337         std::shared_ptr<GeomAPI_Edge> anEdge =
1338             std::dynamic_pointer_cast<GeomAPI_Edge>(aFeature->lastResult()->shape());
1339         if (anEdge) {
1340           std::shared_ptr<GeomAPI_Pnt> aPoint3D = aSketch->to3D(aPoint->x(), aPoint->y());
1341           if (anEdge->isLine())
1342             aPoint3D = anEdge->line()->project(aPoint3D);
1343           else if (anEdge->isCircle())
1344             aPoint3D = anEdge->circle()->project(aPoint3D);
1345           if(aPoint3D)
1346             aPoint = aSketch->to2D(aPoint3D);
1347         }
1348       }
1349     } else {
1350       AttributePoint2DPtr anOtherPoint =
1351           std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aRefAttr->attr());
1352       if (anOtherPoint)
1353         aPoint = anOtherPoint->pnt(); // the reference point is much more precise, use it
1354     }
1355   }
1356
1357   return aPoint;
1358 }
1359
1360 static void threePointsOfFeature(const FeaturePtr& theMacroFeature,
1361                                  std::shared_ptr<GeomAPI_Pnt2d> thePoints[3])
1362 {
1363   if (theMacroFeature->getKind() == SketchPlugin_MacroCircle::ID()) {
1364     thePoints[0] = toPoint(theMacroFeature,
1365           SketchPlugin_MacroCircle::FIRST_POINT_ID(),
1366           SketchPlugin_MacroCircle::FIRST_POINT_REF_ID());
1367     thePoints[1] = toPoint(theMacroFeature,
1368           SketchPlugin_MacroCircle::SECOND_POINT_ID(),
1369           SketchPlugin_MacroCircle::SECOND_POINT_REF_ID());
1370     thePoints[2] = toPoint(theMacroFeature,
1371           SketchPlugin_MacroCircle::THIRD_POINT_ID(),
1372           SketchPlugin_MacroCircle::THIRD_POINT_REF_ID());
1373   } else if (theMacroFeature->getKind() == SketchPlugin_MacroArc::ID()) {
1374     thePoints[0] = toPoint(theMacroFeature,
1375           SketchPlugin_MacroArc::START_POINT_2_ID(),
1376           SketchPlugin_MacroArc::START_POINT_REF_ID());
1377     thePoints[1] = toPoint(theMacroFeature,
1378           SketchPlugin_MacroArc::END_POINT_2_ID(),
1379           SketchPlugin_MacroArc::END_POINT_REF_ID());
1380     thePoints[2] = toPoint(theMacroFeature,
1381           SketchPlugin_MacroArc::PASSED_POINT_ID(),
1382           SketchPlugin_MacroArc::PASSED_POINT_REF_ID());
1383   }
1384 }
1385
1386 static bool isPointsOnLine(const std::shared_ptr<GeomAPI_Pnt2d>& thePoint1,
1387                            const std::shared_ptr<GeomAPI_Pnt2d>& thePoint2,
1388                            const std::shared_ptr<GeomAPI_Pnt2d>& thePoint3)
1389 {
1390   static const double aTolerance = 1.e-7;
1391   if (thePoint1->distance(thePoint2) < aTolerance ||
1392       thePoint1->distance(thePoint3) < aTolerance)
1393     return true;
1394
1395   std::shared_ptr<GeomAPI_Dir2d> aDirP1P2(new GeomAPI_Dir2d(thePoint2->x() - thePoint1->x(),
1396                                                             thePoint2->y() - thePoint1->y()));
1397   std::shared_ptr<GeomAPI_Dir2d> aDirP1P3(new GeomAPI_Dir2d(thePoint3->x() - thePoint1->x(),
1398                                                             thePoint3->y() - thePoint1->y()));
1399   return fabs(aDirP1P2->cross(aDirP1P3)) < aTolerance;
1400 }
1401
1402 static bool isOnSameSide(const std::shared_ptr<GeomAPI_Lin>& theLine,
1403                          const std::shared_ptr<GeomAPI_Pnt>& thePoint1,
1404                          const std::shared_ptr<GeomAPI_Pnt>& thePoint2)
1405 {
1406   static const double aTolerance = 1.e-7;
1407   std::shared_ptr<GeomAPI_Dir> aLineDir = theLine->direction();
1408   std::shared_ptr<GeomAPI_XYZ> aLineLoc = theLine->location()->xyz();
1409
1410   std::shared_ptr<GeomAPI_XYZ> aVec1 = thePoint1->xyz()->decreased(aLineLoc);
1411   // the first point is on the line
1412   if (aVec1->squareModulus() < aTolerance * aTolerance)
1413     return false;
1414   std::shared_ptr<GeomAPI_Dir> aDirP1L(new GeomAPI_Dir(aVec1));
1415   std::shared_ptr<GeomAPI_XYZ> aVec2 = thePoint2->xyz()->decreased(aLineLoc);
1416   // the second point is on the line
1417   if (aVec2->squareModulus() < aTolerance * aTolerance)
1418     return false;
1419   std::shared_ptr<GeomAPI_Dir> aDirP2L(new GeomAPI_Dir(aVec2));
1420
1421   return aLineDir->cross(aDirP1L)->dot(aLineDir->cross(aDirP2L)) > -aTolerance;
1422 }
1423
1424 static bool isOnSameSide(const std::shared_ptr<GeomAPI_Circ>& theCircle,
1425                          const std::shared_ptr<GeomAPI_Pnt>&  thePoint1,
1426                          const std::shared_ptr<GeomAPI_Pnt>&  thePoint2)
1427 {
1428   static const double aTolerance = 1.e-7;
1429   std::shared_ptr<GeomAPI_Pnt> aCenter = theCircle->center();
1430   double aDistP1C = thePoint1->distance(aCenter);
1431   double aDistP2C = thePoint2->distance(aCenter);
1432   return (aDistP1C - theCircle->radius()) * (aDistP2C - theCircle->radius()) > -aTolerance;
1433 }
1434
1435 bool SketchPlugin_ThirdPointValidator::arePointsNotOnLine(
1436     const FeaturePtr& theMacroFeature,
1437     Events_InfoMessage& theError) const
1438 {
1439   static const std::string aErrorPointsOnLine(
1440       "Selected points are on the same line");
1441
1442   std::shared_ptr<GeomAPI_Pnt2d> aPoints[3];
1443   threePointsOfFeature(theMacroFeature, aPoints);
1444
1445   if (isPointsOnLine(aPoints[0], aPoints[1], aPoints[2])) {
1446     theError = aErrorPointsOnLine;
1447     return false;
1448   }
1449   return true;
1450 }
1451
1452 bool SketchPlugin_ThirdPointValidator::arePointsNotSeparated(
1453     const FeaturePtr& theMacroFeature,
1454     const std::list<std::string>& theArguments,
1455     Events_InfoMessage& theError) const
1456 {
1457   static const std::string aErrorPointsApart(
1458       "Selected entity is lying between first two points");
1459
1460   AttributeRefAttrPtr aThirdPointRef = theMacroFeature->refattr(theArguments.front());
1461   FeaturePtr aRefByThird;
1462   if (aThirdPointRef->isObject())
1463     aRefByThird = ModelAPI_Feature::feature(aThirdPointRef->object());
1464   if (!aRefByThird)
1465     return true;
1466
1467   std::shared_ptr<GeomAPI_Pnt2d> aPoints[3];
1468   threePointsOfFeature(theMacroFeature, aPoints);
1469
1470   std::shared_ptr<GeomAPI_Edge> aThirdShape =
1471       std::dynamic_pointer_cast<GeomAPI_Edge>(aRefByThird->lastResult()->shape());
1472   if (!aThirdShape)
1473     return true;
1474
1475   SketchPlugin_Sketch* aSketch =
1476       std::dynamic_pointer_cast<SketchPlugin_Feature>(theMacroFeature)->sketch();
1477   std::shared_ptr<GeomAPI_Pnt> aFirstPnt3D = aSketch->to3D(aPoints[0]->x(), aPoints[0]->y());
1478   std::shared_ptr<GeomAPI_Pnt> aSecondPnt3D = aSketch->to3D(aPoints[1]->x(), aPoints[1]->y());
1479
1480   bool isOk = true;
1481   if (aThirdShape->isLine())
1482     isOk = isOnSameSide(aThirdShape->line(), aFirstPnt3D, aSecondPnt3D);
1483   else if (aThirdShape->isCircle() || aThirdShape->isArc())
1484     isOk = isOnSameSide(aThirdShape->circle(), aFirstPnt3D, aSecondPnt3D);
1485
1486   if (!isOk)
1487     theError = aErrorPointsApart;
1488   return isOk;
1489 }
1490
1491 bool SketchPlugin_ArcEndPointValidator::isValid(
1492     const AttributePtr& theAttribute,
1493     const std::list<std::string>& theArguments,
1494     Events_InfoMessage& theError) const
1495 {
1496   FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
1497   AttributeRefAttrPtr anEndPointRef = aFeature->refattr(theArguments.front());
1498
1499   if(!anEndPointRef.get()) {
1500     return true;
1501   }
1502
1503   ObjectPtr anObject = anEndPointRef->object();
1504   AttributePtr anAttr = anEndPointRef->attr();
1505   if(!anObject.get() && !anAttr.get()) {
1506     return true;
1507   }
1508
1509   if(anEndPointRef->attr().get()) {
1510     return false;
1511   }
1512
1513   ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
1514   if(aResult.get()) {
1515     GeomShapePtr aShape = aResult->shape();
1516     if(aShape.get() && aShape->isVertex()) {
1517       return false;
1518     }
1519   }
1520
1521   aFeature = ModelAPI_Feature::feature(anObject);
1522   if(aFeature.get()) {
1523     if(aFeature->getKind() == SketchPlugin_Point::ID()) {
1524       return false;
1525     }
1526   }
1527
1528   return true;
1529 }
1530
1531 static GeomShapePtr toInfiniteEdge(const GeomShapePtr theShape)
1532 {
1533   if(!theShape.get()) {
1534     return theShape;
1535   }
1536
1537   if(!theShape->isEdge()) {
1538     return theShape;
1539   }
1540
1541   std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(theShape));
1542
1543   if(!anEdge.get()) {
1544     return theShape;
1545   }
1546
1547   if(anEdge->isLine()) {
1548     std::shared_ptr<GeomAPI_Lin> aLine = anEdge->line();
1549     GeomShapePtr aShape = GeomAlgoAPI_EdgeBuilder::line(aLine);
1550     return aShape;
1551   }
1552
1553   if(anEdge->isCircle() || anEdge->isArc()) {
1554     std::shared_ptr<GeomAPI_Circ> aCircle = anEdge->circle();
1555     GeomShapePtr aShape = GeomAlgoAPI_EdgeBuilder::lineCircle(aCircle);
1556     return aShape;
1557   }
1558
1559   return theShape;
1560 }
1561
1562 bool SketchPlugin_ArcEndPointIntersectionValidator::isValid(
1563     const AttributePtr& theAttribute,
1564     const std::list<std::string>& theArguments,
1565     Events_InfoMessage& theError) const
1566 {
1567   std::shared_ptr<SketchPlugin_MacroArc> anArcFeature =
1568       std::dynamic_pointer_cast<SketchPlugin_MacroArc>(theAttribute->owner());
1569   AttributeRefAttrPtr anEndPointRef = anArcFeature->refattr(theArguments.front());
1570
1571   if(!anEndPointRef.get()) {
1572     return true;
1573   }
1574
1575   GeomShapePtr anArcShape = toInfiniteEdge(anArcFeature->getArcShape(false));
1576
1577   if(!anArcShape.get() || anArcShape->isNull()) {
1578     return true;
1579   }
1580
1581   ObjectPtr anObject = anEndPointRef->object();
1582   AttributePtr anAttr = anEndPointRef->attr();
1583   if(!anObject.get() && !anAttr.get()) {
1584     return true;
1585   }
1586
1587   ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
1588   if(aResult.get()) {
1589     GeomShapePtr aShape = aResult->shape();
1590     if (!aShape->isEdge())
1591       return true;
1592     aShape = toInfiniteEdge(aShape);
1593     if(aShape.get() && !aShape->isNull()) {
1594       if(anArcShape->isIntersect(aShape)) {
1595         return true;
1596       }
1597     }
1598   }
1599
1600   FeaturePtr aSelectedFeature = ModelAPI_Feature::feature(anObject);
1601   if(aSelectedFeature.get()) {
1602     std::list<ResultPtr> aResults = aSelectedFeature->results();
1603     for(std::list<ResultPtr>::const_iterator anIt = aResults.cbegin();
1604         anIt != aResults.cend();
1605         ++anIt)
1606     {
1607       GeomShapePtr aShape = (*anIt)->shape();
1608       if (!aShape->isEdge())
1609         return true;
1610       aShape = toInfiniteEdge(aShape);
1611       if(aShape.get() && !aShape->isNull()) {
1612         if(anArcShape->isIntersect(aShape)) {
1613           return true;
1614         }
1615       }
1616     }
1617   }
1618
1619   return false;
1620 }
1621
1622 bool SketchPlugin_HasNoConstraint::isValid(const AttributePtr& theAttribute,
1623                                            const std::list<std::string>& theArguments,
1624                                            Events_InfoMessage& theError) const
1625 {
1626   std::set<std::string> aFeatureKinds;
1627   for (std::list<std::string>::const_iterator anArgIt = theArguments.begin();
1628        anArgIt != theArguments.end(); anArgIt++) {
1629     aFeatureKinds.insert(*anArgIt);
1630   }
1631
1632   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
1633     theError = "The attribute with the %1 type is not processed";
1634     theError.arg(theAttribute->attributeType());
1635     return false;
1636   }
1637
1638   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>
1639                                                                       (theAttribute);
1640   bool isObject = aRefAttr->isObject();
1641   if (!isObject) {
1642     theError = "It uses an empty object";
1643     return false;
1644   }
1645   ObjectPtr anObject = aRefAttr->object();
1646   FeaturePtr aFeature = ModelAPI_Feature::feature(anObject);
1647   if (!aFeature.get()) {
1648     theError = "The feature of the checked attribute is empty";
1649     return false;
1650   }
1651
1652   FeaturePtr aCurrentFeature = ModelAPI_Feature::feature(aRefAttr->owner());
1653
1654   std::set<AttributePtr> aRefsList = anObject->data()->refsToMe();
1655   std::set<AttributePtr>::const_iterator anIt = aRefsList.begin();
1656   for (; anIt != aRefsList.end(); anIt++) {
1657     FeaturePtr aRefFeature = ModelAPI_Feature::feature((*anIt)->owner());
1658     if (aRefFeature.get() && aCurrentFeature != aRefFeature &&
1659         aFeatureKinds.find(aRefFeature->getKind()) != aFeatureKinds.end())
1660       return false; // constraint is found, that means that the check is not valid
1661   }
1662   return true;
1663 }
1664
1665 bool SketchPlugin_ReplicationReferenceValidator::isValid(
1666     const AttributePtr& theAttribute,
1667     const std::list<std::string>& theArguments,
1668     Events_InfoMessage& theError) const
1669 {
1670   AttributeRefAttrPtr aRefAttr =
1671       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
1672   if (!aRefAttr)
1673   {
1674     theError = "Incorrect attribute";
1675     return false;
1676   }
1677
1678   ObjectPtr anOwner;
1679   if (aRefAttr->isObject())
1680     anOwner = aRefAttr->object();
1681   else
1682   {
1683     AttributePtr anAttr = aRefAttr->attr();
1684     anOwner = anAttr->owner();
1685   }
1686   FeaturePtr anAttrOwnerFeature = ModelAPI_Feature::feature(anOwner);
1687   if (!anAttrOwnerFeature)
1688     return true;
1689   AttributeBooleanPtr aCopyAttr = anAttrOwnerFeature->boolean(SketchPlugin_SketchEntity::COPY_ID());
1690   if (!aCopyAttr || !aCopyAttr->value())
1691     return true; // feature is not a copy, thus valid
1692
1693   // check the copy feature is already referred by the "Multi" feature
1694   FeaturePtr aMultiFeature = ModelAPI_Feature::feature(theAttribute->owner());
1695   AttributeRefListPtr aRefList = aMultiFeature->reflist(theArguments.front());
1696   for (int i = 0; i < aRefList->size(); ++i)
1697   {
1698     FeaturePtr aRefOwner = ModelAPI_Feature::feature(aRefList->object(i));
1699     if (aRefOwner == anAttrOwnerFeature)
1700     {
1701       theError = "Attribute refers to the object generated by this feature";
1702       return false;
1703     }
1704   }
1705
1706   return true;
1707 }
1708
1709 bool SketchPlugin_SketchFeatureValidator::isValid(const AttributePtr& theAttribute,
1710                                                   const std::list<std::string>& theArguments,
1711                                                   Events_InfoMessage& theError) const
1712 {
1713   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
1714     theError = "The attribute with the %1 type is not processed";
1715     theError.arg(theAttribute->attributeType());
1716     return false;
1717   }
1718
1719   // check the attribute refers to a sketch feature
1720   AttributeRefAttrPtr aRefAttr =
1721       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
1722   bool isSketchFeature = aRefAttr->isObject();
1723   if (isSketchFeature) {
1724     FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
1725     isSketchFeature = aFeature.get() != NULL;
1726     if (isSketchFeature) {
1727       std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
1728           std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
1729       isSketchFeature = aSketchFeature.get() != NULL;
1730     }
1731   }
1732
1733   if (isSketchFeature)
1734     return true;
1735
1736   theError = "The object selected is not a sketch feature";
1737   return false;
1738 }
1739
1740 bool SketchPlugin_MultiRotationAngleValidator::isValid(const AttributePtr& theAttribute,
1741                                                        const std::list<std::string>& theArguments,
1742                                                        Events_InfoMessage& theError) const
1743 {
1744   if (theAttribute->attributeType() != ModelAPI_AttributeDouble::typeId()) {
1745     theError = "The attribute with the %1 type is not processed";
1746     theError.arg(theAttribute->attributeType());
1747     return false;
1748   }
1749
1750   AttributeDoublePtr anAngleAttr =
1751     std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theAttribute);
1752
1753   FeaturePtr aMultiRotation = ModelAPI_Feature::feature(theAttribute->owner());
1754   AttributeStringPtr anAngleType =
1755       aMultiRotation->string(SketchPlugin_MultiRotation::ANGLE_TYPE());
1756   AttributeIntegerPtr aNbCopies =
1757       aMultiRotation->integer(SketchPlugin_MultiRotation::NUMBER_OF_OBJECTS_ID());
1758
1759   if (anAngleType->value() != "FullAngle")
1760   {
1761     double aFullAngleValue = anAngleAttr->value() * (aNbCopies->value() - 1);
1762     if (aFullAngleValue < -1.e-7 || aFullAngleValue > 359.9999999)
1763     {
1764       theError = "Rotation single angle should produce full angle less than 360 degree";
1765       return false;
1766     }
1767   }
1768   else
1769   {
1770     double aFullAngleValue = anAngleAttr->value();
1771     if (aFullAngleValue < -1.e-7 || aFullAngleValue > 360.0000001)
1772     {
1773       theError = "Rotation full angle should be in range [0, 360]";
1774       return false;
1775     }
1776   }
1777
1778   return true;
1779 }