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