]> SALOME platform Git repositories - modules/shaper.git/blob - src/PartSet/PartSet_Validators.cpp
Salome HOME
32fea83989156974e215e1ba842a8fc613b67ce2
[modules/shaper.git] / src / PartSet / PartSet_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 "PartSet_Validators.h"
22
23 #include "PartSet_Tools.h"
24 #include "PartSet_SketcherMgr.h"
25
26 #include <TopoDS.hxx>
27 #include <TopoDS_Edge.hxx>
28 #include <BRep_Tool.hxx>
29 #include <GeomAdaptor_Curve.hxx>
30 #include <GeomAbs_CurveType.hxx>
31 #include <ModuleBase_ISelection.h>
32 #include <ModuleBase_WidgetShapeSelector.h>
33 #include <ModuleBase_OperationFeature.h>
34 #include <ModuleBase_ViewerPrs.h>
35
36 #include <GeomDataAPI_Point2D.h>
37 #include <GeomAPI_Pnt2d.h>
38
39 #include <Events_InfoMessage.h>
40
41 #include <ModelAPI_AttributeRefAttr.h>
42 #include <ModelAPI_AttributeSelection.h>
43 #include <ModelAPI_AttributeReference.h>
44 #include <ModelAPI_AttributeSelectionList.h>
45 #include <ModelAPI_AttributeRefList.h>
46 #include <ModelAPI_Object.h>
47 #include <ModelAPI_ResultBody.h>
48 #include <ModelAPI_Session.h>
49 #include <ModelAPI_Tools.h>
50
51 #include <SketchPlugin_Sketch.h>
52 #include <SketchPlugin_ConstraintCoincidence.h>
53 #include <SketchPlugin_Arc.h>
54 #include <SketchPlugin_Point.h>
55 #include <GeomAPI_Edge.h>
56
57 #include <list>
58 #ifdef _DEBUG
59 #include <iostream>
60 #endif
61
62 int shapesNbPoints(const ModuleBase_ISelection* theSelection)
63 {
64   QList<ModuleBase_ViewerPrsPtr> aList = theSelection->getSelected(ModuleBase_ISelection::Viewer);
65   ModuleBase_ISelection::filterSelectionOnEqualPoints(aList);
66
67   int aCount = 0;
68   foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
69     const GeomShapePtr& aShape = aPrs->shape();
70     if (aShape.get() && !aShape->isNull()) {
71       if (aShape->shapeType() == GeomAPI_Shape::VERTEX)
72         aCount++;
73     }
74   }
75   return aCount;
76 }
77
78 int shapesNbLines(const ModuleBase_ISelection* theSelection)
79 {
80   QList<ModuleBase_ViewerPrsPtr> aList = theSelection->getSelected(ModuleBase_ISelection::Viewer);
81   int aCount = 0;
82   foreach(ModuleBase_ViewerPrsPtr aPrs, aList) {
83     const GeomShapePtr& aShape = aPrs->shape();
84     if (aShape.get() && !aShape->isNull()) {
85       if (aShape->shapeType() == GeomAPI_Shape::EDGE) {
86         const TopoDS_Shape& aTDShape = aShape->impl<TopoDS_Shape>();
87         TopoDS_Edge aEdge = TopoDS::Edge(aTDShape);
88         Standard_Real aStart, aEnd;
89         Handle(Geom_Curve) aCurve = BRep_Tool::Curve(aEdge, aStart, aEnd);
90         GeomAdaptor_Curve aAdaptor(aCurve);
91         if (aAdaptor.GetType() == GeomAbs_Line)
92           aCount++;
93       }
94     }
95   }
96   return aCount;
97 }
98
99
100 std::shared_ptr<GeomAPI_Pln> sketcherPlane(ModuleBase_Operation* theOperation)
101 {
102   std::shared_ptr<GeomAPI_Pln> aEmptyPln;
103   if (theOperation) {
104     ModuleBase_OperationFeature* aFeatureOp =
105       dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
106     if (aFeatureOp) {
107       CompositeFeaturePtr aFeature =
108         std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeatureOp->feature());
109       if (aFeature && (aFeature->getKind() == SketchPlugin_Sketch::ID()))
110         return PartSet_Tools::sketchPlane(aFeature);
111     }
112   }
113   return aEmptyPln;
114 }
115
116
117 bool isEmptySelectionValid(ModuleBase_Operation* theOperation)
118 {
119   ModuleBase_OperationFeature* aFeatureOp =
120     dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
121   // during the create operation empty selection is always valid
122   if (!aFeatureOp->isEditOperation()) {
123     return true;
124   }
125   else {
126     if (PartSet_SketcherMgr::isSketchOperation(aFeatureOp)) {
127       std::shared_ptr<GeomAPI_Pln> aPlane = sketcherPlane(theOperation);
128       if (aPlane.get())
129         return true;
130       else
131         return false;
132     }
133     else
134       // in edit operation an empty selection is always valid, performed for re-entrant operrations
135       return true;
136   }
137 }
138
139 bool PartSet_DistanceSelection::isValid(const ModuleBase_ISelection* theSelection,
140                                         ModuleBase_Operation* theOperation) const
141 {
142   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
143     return isEmptySelectionValid(theOperation);
144   } else {
145     int aCount = shapesNbPoints(theSelection) + shapesNbLines(theSelection);
146     return (aCount > 0) && (aCount < 3);
147   }
148 }
149
150 bool PartSet_LengthSelection::isValid(const ModuleBase_ISelection* theSelection,
151                                       ModuleBase_Operation* theOperation) const
152 {
153   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
154     return isEmptySelectionValid(theOperation);
155   } else {
156     int aCount = shapesNbLines(theSelection);
157     return (aCount == 1);
158   }
159 }
160
161 bool PartSet_PerpendicularSelection::isValid(const ModuleBase_ISelection* theSelection,
162                                              ModuleBase_Operation* theOperation) const
163 {
164   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
165     return isEmptySelectionValid(theOperation);
166   } else {
167     int aCount = shapesNbLines(theSelection);
168     return (aCount > 0) && (aCount < 3);
169   }
170 }
171
172 bool PartSet_ParallelSelection::isValid(const ModuleBase_ISelection* theSelection,
173                                         ModuleBase_Operation* theOperation) const
174 {
175   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
176     return isEmptySelectionValid(theOperation);
177   } else {
178     int aCount = shapesNbLines(theSelection);
179     return (aCount > 0) && (aCount < 3);
180   }
181 }
182
183 bool PartSet_RadiusSelection::isValid(const ModuleBase_ISelection* theSelection,
184                                       ModuleBase_Operation* theOperation) const
185 {
186   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
187     return isEmptySelectionValid(theOperation);
188   } else {
189     QList<ModuleBase_ViewerPrsPtr> aList =
190       theSelection->getSelected(ModuleBase_ISelection::Viewer);
191     int aCount = 0;
192     foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
193       const GeomShapePtr& aShape = aPrs->shape();
194       if (aShape.get() && !aShape->isNull()) {
195         if (aShape->shapeType() == GeomAPI_Shape::EDGE) {
196           const TopoDS_Shape& aTDShape = aShape->impl<TopoDS_Shape>();
197           TopoDS_Edge aEdge = TopoDS::Edge(aTDShape);
198           Standard_Real aStart, aEnd;
199           Handle(Geom_Curve) aCurve = BRep_Tool::Curve(aEdge, aStart, aEnd);
200           GeomAdaptor_Curve aAdaptor(aCurve);
201           if (aAdaptor.GetType() == GeomAbs_Circle)
202             aCount++;
203         }
204       }
205     }
206     return (aCount == 1);
207   }
208 }
209
210 bool PartSet_RigidSelection::isValid(const ModuleBase_ISelection* theSelection,
211                                      ModuleBase_Operation* theOperation) const
212 {
213   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
214     return isEmptySelectionValid(theOperation);
215   } else {
216     QList<ModuleBase_ViewerPrsPtr> aList =
217       theSelection->getSelected(ModuleBase_ISelection::Viewer);
218     int aCount = 0;
219     foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
220       ObjectPtr aObj = aPrs->object();
221       if (aObj.get()) {
222         FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
223         if (aFeature.get()) {
224           CompositeFeaturePtr aComp = ModelAPI_Tools::compositeOwner(aFeature);
225           if (aComp.get() && (aComp->getKind() == SketchPlugin_Sketch::ID()))
226             aCount++;
227         }
228       }
229     }
230     return (aCount == 1);
231   }
232 }
233
234
235 bool PartSet_CoincidentSelection::isValid(const ModuleBase_ISelection* theSelection,
236                                           ModuleBase_Operation* theOperation) const
237 {
238   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
239     return isEmptySelectionValid(theOperation);
240   } else {
241     // Coincident can be applied to points and to lines
242     int aCount = shapesNbPoints(theSelection);
243     aCount += shapesNbLines(theSelection);
244     return (aCount > 0) && (aCount < 3);
245   }
246 }
247
248 bool PartSet_HVDirSelection::isValid(const ModuleBase_ISelection* theSelection,
249                                      ModuleBase_Operation* theOperation) const
250 {
251   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
252     return isEmptySelectionValid(theOperation);
253   } else {
254     int aCount = shapesNbLines(theSelection);
255     return (aCount == 1);
256   }
257 }
258
259 bool PartSet_FilletSelection::isValid(const ModuleBase_ISelection* theSelection,
260                                       ModuleBase_Operation* theOperation) const
261 {
262   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
263     return isEmptySelectionValid(theOperation);
264   } else {
265     int aCount = shapesNbPoints(theSelection);
266     return aCount > 1;
267   }
268 }
269
270 bool PartSet_TangentSelection::isValid(const ModuleBase_ISelection* theSelection,
271                                        ModuleBase_Operation* theOperation) const
272 {
273   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
274     return isEmptySelectionValid(theOperation);
275   } else {
276     QList<ModuleBase_ViewerPrsPtr> aList = theSelection->getSelected(ModuleBase_ISelection::Viewer);
277     if ((aList.size() == 0) || (aList.size() > 2))
278       return false;
279
280     ModuleBase_ViewerPrsPtr aPrs = aList.first();
281     const GeomShapePtr& aShape = aPrs->shape();
282     if (!aShape.get() || aShape->isNull() || aShape->shapeType() != GeomAPI_Shape::EDGE)
283       return false;
284     GeomAPI_Edge aEdge1(aShape);
285
286     if (aEdge1.isLine() || aEdge1.isArc()) {
287       if (aList.size() == 2) {
288         // Check second selection
289         aPrs = aList.last();
290         const GeomShapePtr& aShape2 = aPrs->shape();
291         if (!aShape2.get() || aShape2->isNull() || aShape2->shapeType() != GeomAPI_Shape::EDGE)
292           return false;
293         GeomAPI_Edge aEdge2(aShape2);
294
295         if (aEdge1.isLine() && aEdge2.isArc())
296           return true;
297         else if (aEdge1.isArc() && aEdge2.isLine())
298           return true;
299         else
300           return false;
301       } else
302         return true;
303     }
304     return false;
305   }
306 }
307
308 bool PartSet_AngleSelection::isValid(const ModuleBase_ISelection* theSelection,
309                                      ModuleBase_Operation* theOperation) const
310 {
311   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
312     return isEmptySelectionValid(theOperation);
313   } else {
314     int aCount = shapesNbLines(theSelection);
315     return (aCount > 0) && (aCount < 3);
316   }
317 }
318
319 bool PartSet_EqualSelection::isValid(const ModuleBase_ISelection* theSelection,
320                                      ModuleBase_Operation* theOperation) const
321 {
322   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
323     return isEmptySelectionValid(theOperation);
324   } else {
325     QList<ModuleBase_ViewerPrsPtr> aList =
326       theSelection->getSelected(ModuleBase_ISelection::Viewer);
327     int aCount = 0;
328     int aType = 0;
329     foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
330       GeomShapePtr aShape = aPrs->shape();
331       if (aShape.get() && aShape->isEdge()) {
332         aCount++;
333         GeomAPI_Edge aEdge(aShape);
334         if (aEdge.isLine()) {
335           if (aCount == 1)
336             aType = 1;
337           else if (aType != 1)
338             return false;
339         } else if (aEdge.isCircle()) {
340           if (aCount == 1)
341             aType = 2;
342           else if (aType != 2)
343             return false;
344         } else if (aEdge.isArc()) {
345           if (aCount == 1)
346             aType = 3;
347           else if (aType != 3)
348             return false;
349         }
350       } else
351         return false;
352     }
353     return (aCount > 0) && (aCount < 3);
354   }
355 }
356
357 bool PartSet_CollinearSelection::isValid(const ModuleBase_ISelection* theSelection,
358                                          ModuleBase_Operation* theOperation) const
359 {
360   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
361     return isEmptySelectionValid(theOperation);
362   } else {
363     int aCount = shapesNbLines(theSelection);
364     return (aCount > 0) && (aCount < 3);
365   }
366 }
367
368 bool PartSet_MiddlePointSelection::isValid(const ModuleBase_ISelection* theSelection,
369                                            ModuleBase_Operation* theOperation) const
370 {
371   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0)
372     return isEmptySelectionValid(theOperation);
373   else
374     return shapesNbLines(theSelection) == 1 || shapesNbPoints(theSelection) == 1;
375 }
376
377 bool PartSet_MultyTranslationSelection::isValid(const ModuleBase_ISelection* theSelection,
378                                      ModuleBase_Operation* theOperation) const
379 {
380   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
381     return isEmptySelectionValid(theOperation);
382   } else {
383     int aCount = shapesNbLines(theSelection);
384     return aCount > 0;
385   }
386 }
387
388 bool PartSet_SplitSelection::isValid(const ModuleBase_ISelection* theSelection,
389                                      ModuleBase_Operation* theOperation) const
390 {
391   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
392     return isEmptySelectionValid(theOperation);
393   } else {
394     int aCount = shapesNbLines(theSelection);
395     return aCount > 0;
396   }
397 }
398
399 bool PartSet_ProjectionSelection::isValid(const ModuleBase_ISelection* theSelection,
400                                      ModuleBase_Operation* theOperation) const
401 {
402   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
403     return isEmptySelectionValid(theOperation);
404   } else {
405     int aCount = shapesNbLines(theSelection);
406     return aCount > 0;
407   }
408 }
409
410 bool PartSet_IntersectionSelection::isValid(const ModuleBase_ISelection* theSelection,
411                                      ModuleBase_Operation* theOperation) const
412 {
413   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
414     return isEmptySelectionValid(theOperation);
415   } else {
416     int aCount = shapesNbLines(theSelection);
417     return aCount == 0;
418   }
419 }
420
421
422 std::string PartSet_DifferentObjectsValidator::errorMessage(
423                          const PartSet_DifferentObjectsValidator::ErrorType& theType,
424                          const std::string& thEqualObject, const std::string& theFirstAttribute,
425                          const std::string& theSecondAttribute) const
426 {
427   std::string anError;
428   switch (theType) {
429     case EqualObjects:
430       anError = "The feature uses one " + thEqualObject + " object in " +
431                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
432       break;
433     case EqualAttributes:
434       anError = "The feature uses reference to one " + thEqualObject + " attribute in " +
435                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
436       break;
437     case EqualShapes:
438       anError = "The feature uses one shape in " +
439                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
440       break;
441     case EmptyShapes:
442       anError = "The feature uses empty shapes in " +
443                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
444       break;
445       break;
446     default:
447       break;
448   }
449   return anError;
450 }
451
452 bool PartSet_DifferentObjectsValidator::isValid(const AttributePtr& theAttribute,
453                                                 const std::list<std::string>& theArguments,
454                                                 Events_InfoMessage& theError) const
455 {
456   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
457
458   // the type of validated attributes should be equal, attributes with
459   // different types are not validated
460   // Check RefAttr attributes
461   std::string anAttrType = theAttribute->attributeType();
462   std::list<std::shared_ptr<ModelAPI_Attribute> > anAttrs;
463
464   if (anAttrType == ModelAPI_AttributeRefAttr::typeId()) {
465     AttributeRefAttrPtr anAttr =
466       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
467     bool isObject = anAttr->isObject();
468     ObjectPtr anObject = anAttr->object();
469
470     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
471     if (anAttrs.size() > 0) {
472       std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttrIter = anAttrs.begin();
473       for(; anAttrIter != anAttrs.end(); anAttrIter++) {
474       if ((*anAttrIter).get() && (*anAttrIter)->id() != theAttribute->id()) {
475           std::shared_ptr<ModelAPI_AttributeRefAttr> aRef =
476                               std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIter);
477           if (aRef->isObject() != isObject)
478             continue;
479           if (isObject) {
480             if (aRef->object() == anObject) {
481               theError = errorMessage(EqualObjects, anObject.get() ? anObject->data()->name() : "",
482                                       theAttribute->id(), aRef->id());
483               return false;
484             }
485           }
486           else { // the attribute reference
487             AttributePtr anAttributeAttr = anAttr->attr();
488             if (aRef->attr() == anAttributeAttr) {
489               theError = errorMessage(EqualAttributes,
490                                       anAttributeAttr.get() ? anAttributeAttr->id() : "",
491                                       theAttribute->id(), aRef->id());
492               return false;
493             }
494           }
495         }
496       }
497     }
498   }
499   else if (anAttrType == ModelAPI_AttributeSelection::typeId()) {
500     AttributeSelectionPtr anAttr =
501       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
502     ResultPtr aContext = anAttr->context();
503     GeomShapePtr aShape = anAttr->value();
504
505     // Check selection attributes
506     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeSelection::typeId());
507     if (anAttrs.size() > 0) {
508       std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
509       for(; anAttr != anAttrs.end(); anAttr++) {
510         if ((*anAttr).get() && (*anAttr)->id() != theAttribute->id()) {
511           std::shared_ptr<ModelAPI_AttributeSelection> aRef =
512                               std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(*anAttr);
513           // check the object is already presented
514           if (aRef->context() == aContext) {
515             bool aHasShape = aShape.get() != NULL;
516             if (!aHasShape || aRef->value()->isEqual(aShape)) {
517               theError = errorMessage(EqualShapes, "", theAttribute->id(), aRef->id());
518               return false;
519             }
520           }
521         }
522       }
523     }
524   }
525   else if (anAttrType == ModelAPI_AttributeReference::typeId()) {
526     AttributeReferencePtr anAttr =
527       std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
528     ObjectPtr anObject = anAttr->value();
529     // Check selection attributes
530     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeReference::typeId());
531     if (anAttrs.size() > 0) {
532       std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
533       for(; anAttr != anAttrs.end(); anAttr++) {
534         if ((*anAttr).get() && (*anAttr)->id() != theAttribute->id()) {
535           std::shared_ptr<ModelAPI_AttributeReference> aRef =
536             std::dynamic_pointer_cast<ModelAPI_AttributeReference>(*anAttr);
537           // check the object is already presented
538           if (aRef->value() == anObject) {
539             theError = errorMessage(EqualObjects, anObject.get() ? anObject->data()->name() : "",
540                                     theAttribute->id(), aRef->id());
541             return false;
542           }
543         }
544         return true;
545       }
546     }
547   }
548   else if(anAttrType == ModelAPI_AttributeSelectionList::typeId()) {
549     std::shared_ptr<ModelAPI_AttributeSelectionList> aCurSelList =
550             std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
551     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeSelectionList::typeId());
552     if(anAttrs.size() > 0) {
553       std::list<std::shared_ptr<ModelAPI_Attribute>>::iterator anAttrItr = anAttrs.begin();
554       for(; anAttrItr != anAttrs.end(); anAttrItr++){
555         if ((*anAttrItr).get() && (*anAttrItr)->id() != theAttribute->id()){
556           std::shared_ptr<ModelAPI_AttributeSelectionList> aRefSelList =
557             std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(*anAttrItr);
558           for(int i = 0; i < aCurSelList->size(); i++) {
559             std::shared_ptr<ModelAPI_AttributeSelection> aCurSel = aCurSelList->value(i);
560             ResultPtr aCurSelContext = aCurSel->context();
561             ResultBodyPtr aCurSelCompSolidPtr = ModelAPI_Tools::bodyOwner(aCurSelContext);
562             std::shared_ptr<GeomAPI_Shape> aCurSelCompSolid;
563             if(aCurSelCompSolidPtr.get()) {
564               aCurSelCompSolid = aCurSelCompSolidPtr->shape();
565             }
566             for(int j = 0; j < aRefSelList->size(); j++) {
567               std::shared_ptr<ModelAPI_AttributeSelection> aRefSel = aRefSelList->value(j);
568               ResultPtr aRefSelContext = aRefSel->context();
569               ResultBodyPtr aRefSelCompSolidPtr =
570                 ModelAPI_Tools::bodyOwner(aRefSelContext);
571               std::shared_ptr<GeomAPI_Shape> aRefSelCompSolid;
572               if(aRefSelCompSolidPtr.get()) {
573                 aRefSelCompSolid = aRefSelCompSolidPtr->shape();
574               }
575               if ((aCurSelCompSolid.get() && aCurSelCompSolid->isEqual(aRefSel->value()))
576                 || (aRefSelCompSolid.get() && aRefSelCompSolid->isEqual(aCurSel->value()))) {
577                   theError = errorMessage(EqualShapes, "", theAttribute->id(),
578                                           aRefSel->id());
579                   return false;
580               }
581               if(aCurSelContext == aRefSelContext) {
582                 if (aCurSel->value().get() == NULL || aRefSel->value().get() == NULL) {
583                   theError = errorMessage(EmptyShapes, "", theAttribute->id(),
584                                           aRefSel->id());
585                   return false;
586                 }
587                 if (aCurSel->value()->isEqual(aRefSel->value())) {
588                   theError = errorMessage(EqualShapes, "", theAttribute->id(),
589                                           aRefSel->id());
590                   return false;
591                 }
592               }
593             }
594           }
595         }
596       }
597     }
598   }
599   else if (anAttrType == ModelAPI_AttributeRefList::typeId()) {
600     std::shared_ptr<ModelAPI_AttributeRefList> aCurSelList =
601       std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(theAttribute);
602     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeRefList::typeId());
603     if (anAttrs.size() > 0) {
604       std::list<std::shared_ptr<ModelAPI_Attribute>>::iterator anAttrItr = anAttrs.begin();
605       for (; anAttrItr != anAttrs.end(); anAttrItr++){
606         if ((*anAttrItr).get() && (*anAttrItr)->id() != theAttribute->id()){
607           std::shared_ptr<ModelAPI_AttributeRefList> aRefSelList =
608             std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrItr);
609           for (int i = 0; i < aCurSelList->size(); i++) {
610             ObjectPtr aCurSelObject = aCurSelList->object(i);
611             for (int j = 0; j < aRefSelList->size(); j++) {
612               if (aCurSelObject == aRefSelList->object(j)) {
613                 theError = errorMessage(EqualObjects,
614                               aCurSelObject.get() ? aCurSelObject->data()->name() : "",
615                               theAttribute->id(), aCurSelList->id());
616                 return false;
617               }
618             }
619           }
620         }
621       }
622     }
623   }
624   return true;
625 }
626
627 bool PartSet_DifferentPointsValidator::isValid(const AttributePtr& theAttribute,
628                                                const std::list<std::string>& theArguments,
629                                                Events_InfoMessage& theError) const
630 {
631   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
632
633   // the type of validated attributes should be equal, attributes with
634   // different types are not validated
635   // Check RefAttr attributes
636   std::string anAttrType = theAttribute->attributeType();
637   std::list<std::shared_ptr<ModelAPI_Attribute> > anAttrs;
638   if (anAttrType != ModelAPI_AttributeRefAttr::typeId())
639     return true;
640
641   // obtain point of the given attribute
642   AttributePoint2DPtr anAttributePoint = getRefPointAttribute(theAttribute);
643   if (!anAttributePoint.get() || !anAttributePoint->isInitialized())
644     return true;
645
646   // obtain point of the parameter attribute
647   AttributePoint2DPtr anArgumentPoint = getRefPointAttribute
648                                               (aFeature->attribute(theArguments.front()));
649
650   if (!anArgumentPoint.get() || !anArgumentPoint->isInitialized())
651     return true;
652
653   return !anAttributePoint->pnt()->isEqual(anArgumentPoint->pnt());
654 }
655
656 AttributePoint2DPtr PartSet_DifferentPointsValidator::getRefPointAttribute
657                                                      (const AttributePtr& theAttribute) const
658 {
659   AttributeRefAttrPtr anAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
660
661   AttributePoint2DPtr aPointAttribute;
662   if (anAttr->isObject()) {
663     ObjectPtr anObject  = anAttr->object();
664     if (anObject.get()) {
665       FeaturePtr aFeature = ModelAPI_Feature::feature(anObject);
666       if (aFeature->getKind() == SketchPlugin_Point::ID())
667         aPointAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>
668                                           (aFeature->attribute(SketchPlugin_Point::COORD_ID()));
669     }
670   }
671   else {
672     aPointAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr->attr());
673   }
674   return aPointAttribute;
675 }
676
677 bool PartSet_CoincidentAttr::isValid(const AttributePtr& theAttribute,
678                                      const std::list<std::string>& theArguments,
679                                      Events_InfoMessage& theError) const
680 {
681   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
682     theError = "The attribute with the %1 type is not processed";
683     theError.arg(theAttribute->attributeType());
684     return false;
685   }
686
687   // there is a check whether the feature contains a point and a linear edge or two point values
688   std::string aParamA = theArguments.front();
689   SessionPtr aMgr = ModelAPI_Session::get();
690   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
691
692   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
693   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
694   QList<FeaturePtr> aCoinsideLines;
695   QList<FeaturePtr> aCoins;
696
697   bool isObject = aRefAttr->isObject();
698   ObjectPtr anObject = aRefAttr->object();
699   if (isObject && anObject) {
700     FeaturePtr aRefFea = ModelAPI_Feature::feature(anObject);
701     AttributeRefAttrPtr aOtherAttr = aFeature->data()->refattr(aParamA);
702     ObjectPtr aOtherObject = aOtherAttr->object();
703     // if the other attribute is not filled still, the result is true
704     if (!aOtherObject.get())
705       return true;
706     FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject);
707
708     // check that both have coincidence
709     FeaturePtr aConstrFeature;
710     std::set<FeaturePtr> aCoinList;
711     const std::set<std::shared_ptr<ModelAPI_Attribute>>& aRefsList = aRefFea->data()->refsToMe();
712     std::set<std::shared_ptr<ModelAPI_Attribute>>::const_iterator aIt;
713     for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
714       std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
715       aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
716       if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
717         AttributeRefAttrPtr aRAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(aAttr);
718         AttributePtr aAR = aRAttr->attr();
719         if (aAR->id() != SketchPlugin_Arc::CENTER_ID()) // ignore constraint to center of arc
720           aCoinList.insert(aConstrFeature);
721           QList<bool> anIsAttributes;
722           PartSet_Tools::findCoincidences(aConstrFeature, aCoinsideLines, aCoins,
723                                           SketchPlugin_ConstraintCoincidence::ENTITY_A(),
724                                           anIsAttributes);
725           PartSet_Tools::findCoincidences(aConstrFeature, aCoinsideLines, aCoins,
726                                           SketchPlugin_ConstraintCoincidence::ENTITY_B(),
727                                           anIsAttributes);
728       }
729     }
730     // if there is no coincidence then it is not valid
731     if (aCoinList.size() > 0) {
732       QList<FeaturePtr>::const_iterator anIt = aCoinsideLines.begin(), aLast = aCoinsideLines.end();
733       bool aValid = false;
734       for (; anIt != aLast && !aValid; anIt++) {
735         aValid = *anIt == aOtherFea;
736       }
737       if (aValid)
738         return true;
739     }
740   }
741   theError = "There is no a common coincident point.";
742   return false;
743 }