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