]> SALOME platform Git repositories - modules/shaper.git/blob - src/FeaturesPlugin/FeaturesPlugin_Validators.cpp
Salome HOME
Issue #2052: Modification of parameters don't work (sketch, extrusion)
[modules/shaper.git] / src / FeaturesPlugin / FeaturesPlugin_Validators.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
2
3 // File:        FeaturesPlugin_Validators.cpp
4 // Created:     22 March 2016
5 // Author:      Dmitry Bobylev
6
7 #include "FeaturesPlugin_Validators.h"
8
9 #include "FeaturesPlugin_Union.h"
10
11 #include <Events_InfoMessage.h>
12
13 #include <ModelAPI_Attribute.h>
14 #include <ModelAPI_AttributeInteger.h>
15 #include <ModelAPI_AttributeSelectionList.h>
16 #include <ModelAPI_AttributeString.h>
17 #include <ModelAPI_AttributeReference.h>
18 #include <ModelAPI_AttributeRefList.h>
19 #include <ModelAPI_Feature.h>
20 #include <ModelAPI_ResultCompSolid.h>
21 #include <ModelAPI_ResultConstruction.h>
22 #include <ModelAPI_Tools.h>
23
24 #include <GeomValidators_BodyShapes.h>
25 #include <GeomValidators_FeatureKind.h>
26 #include <GeomValidators_ShapeType.h>
27
28 #include <GeomAPI_DataMapOfShapeShape.h>
29 #include <GeomAPI_Lin.h>
30 #include <GeomAPI_PlanarEdges.h>
31 #include <GeomAPI_ShapeExplorer.h>
32 #include <GeomAPI_ShapeIterator.h>
33
34 #include <GeomAlgoAPI_CompoundBuilder.h>
35 #include <GeomAlgoAPI_ShapeBuilder.h>
36 #include <GeomAlgoAPI_ShapeTools.h>
37 #include <GeomAlgoAPI_WireBuilder.h>
38
39 #define _USE_MATH_DEFINES
40 #include <math.h>
41
42 //==================================================================================================
43 bool FeaturesPlugin_ValidatorPipePath::isValid(const AttributePtr& theAttribute,
44                                                const std::list<std::string>& theArguments,
45                                                Events_InfoMessage& theError) const
46 {
47   AttributeSelectionPtr aPathAttrSelection =
48     std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
49   if(!aPathAttrSelection.get()) {
50     theError = "Error: This validator can only work with path selector in \"Pipe\" feature.";
51     return false;
52   }
53
54   GeomShapePtr aPathShape = aPathAttrSelection->value();
55   ResultPtr aContext = aPathAttrSelection->context();
56   if(!aContext.get()) {
57     theError = "Error: Empty context.";
58     return false;
59   }
60   GeomShapePtr aContextShape = aContext->shape();
61   if(aPathShape.get() && aPathShape->shapeType() == GeomAPI_Shape::WIRE &&
62       !aPathShape->isEqual(aContextShape)) {
63     theError = "Error: Local selection of wires not allowed.";
64     return false;
65   }
66
67   return true;
68 }
69
70 //==================================================================================================
71 bool FeaturesPlugin_ValidatorPipeLocations::isValid(
72   const std::shared_ptr<ModelAPI_Feature>& theFeature,
73   const std::list<std::string>& theArguments,
74   Events_InfoMessage& theError) const
75 {
76   static const std::string aCreationMethodID = "creation_method";
77   static const std::string aBaseObjectsID = "base_objects";
78   static const std::string aLocationsID = "locations_objects";
79
80   if(theFeature->getKind() != "Pipe") {
81     theError = "Error: Feature \"%1\" does not supported by this validator.";
82     theError.arg(theFeature->getKind());
83     return false;
84   }
85
86   AttributeStringPtr aCreationMethodAttr = theFeature->string(aCreationMethodID);
87   if(!aCreationMethodAttr.get()) {
88     theError = "Error: Could not get \"%1\" attribute.";
89     theError.arg(aCreationMethodID);
90     return false;
91   }
92
93   if(aCreationMethodAttr->value() != "locations") {
94     return true;
95   }
96
97   AttributeSelectionListPtr aBaseObjectsSelectionList = theFeature->selectionList(aBaseObjectsID);
98   if(!aBaseObjectsSelectionList.get()) {
99     theError = "Error: Could not get \"%1\" attribute.";
100     theError.arg(aBaseObjectsID);
101     return false;
102   }
103
104   AttributeSelectionListPtr aLocationsSelectionList = theFeature->selectionList(aLocationsID);
105   if(!aLocationsSelectionList.get()) {
106     theError = "Error: Could not get \"%1\" attribute.";
107     theError.arg(aBaseObjectsID);
108     return false;
109   }
110
111   if(aLocationsSelectionList->size() > 0 &&
112      aLocationsSelectionList->size() != aBaseObjectsSelectionList->size()) {
113     theError = "Error: Number of locations should be the same as base objects.";
114     return false;
115   }
116
117   return true;
118 }
119
120 //==================================================================================================
121 bool FeaturesPlugin_ValidatorPipeLocations::isNotObligatory(std::string theFeature,
122                                                             std::string theAttribute)
123 {
124   return false;
125 }
126
127 //==================================================================================================
128 bool FeaturesPlugin_ValidatorBaseForGeneration::isValid(const AttributePtr& theAttribute,
129                                                         const std::list<std::string>& theArguments,
130                                                         Events_InfoMessage& theError) const
131 {
132   if(theArguments.empty()) {
133     theError = "Error: Validator parameters is empty.";
134     return false;
135   }
136
137   // Checking attribute.
138   if(!isValidAttribute(theAttribute, theArguments, theError)) {
139     if(theError.empty()) {
140       theError = "Error: Attribute contains unacceptable shape.";
141     }
142     return false;
143   }
144
145   std::set<ResultConstructionPtr> aSelectedSketches;
146   std::set<ResultConstructionPtr> aSelectedSketchesFromObjects;
147   GeomAPI_DataMapOfShapeShape aSelectedWiresFromObjects;
148   std::string anAttributeType = theAttribute->attributeType();
149   if(anAttributeType == ModelAPI_AttributeSelectionList::typeId()) {
150     AttributeSelectionListPtr aListAttr =
151       std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
152     for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
153       AttributeSelectionPtr aSelectionAttr = aListAttr->value(anIndex);
154       ResultPtr aContext = aSelectionAttr->context();
155       if(!aContext.get()) {
156         theError = "Error: Empty context.";
157         return false;
158       }
159
160       ResultConstructionPtr aResultConstruction =
161         std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
162       if(!aResultConstruction.get()) {
163         // It is not a result construction.
164         // If shape is compound check that it contains only faces and edges.
165         GeomShapePtr aShape = aSelectionAttr->value();
166         if(!aShape.get()) {
167           aShape = aContext->shape();
168         }
169
170         if(aShape->shapeType() == GeomAPI_Shape::COMPOUND) {
171           for(GeomAPI_ShapeIterator anIt(aShape); anIt.more(); anIt.next()) {
172             GeomShapePtr aSubShape = anIt.current();
173             if(aSubShape->shapeType() != GeomAPI_Shape::EDGE
174                 && aSubShape->shapeType() != GeomAPI_Shape::FACE) {
175               theError = "Error: Compound should contain only faces and edges.";
176               return false;
177             }
178           }
179         }
180
181         continue;
182       }
183
184       GeomShapePtr aShape = aSelectionAttr->value();
185       GeomShapePtr aContextShape = aResultConstruction->shape();
186       if(!aShape.get()) {
187         // Whole sketch selected.
188         if(aSelectedSketchesFromObjects.find(aResultConstruction) !=
189             aSelectedSketchesFromObjects.cend()) {
190           theError = "Error: Object from this sketch is already selected. "
191                      "Sketch is not allowed for selection.";
192           return false;
193         }
194
195         aSelectedSketches.insert(aResultConstruction);
196       } else {
197         // Object from sketch selected.
198         if(aSelectedSketches.find(aResultConstruction) != aSelectedSketches.cend()) {
199           theError = "Error: Whole sketch with this object is already selected. "
200                      "Don't allow to select this object.";
201           return false;
202         }
203
204         for(GeomAPI_ShapeExplorer anExp(aShape, GeomAPI_Shape::WIRE); anExp.more(); anExp.next()) {
205           GeomShapePtr aWire = anExp.current();
206           if(aWire->orientation() != GeomAPI_Shape::FORWARD) {
207             theError = "Error: Wire with wrong orientation selected.";
208             return false;
209           }
210
211           if(aSelectedWiresFromObjects.isBound(aWire)) {
212             theError =
213               "Error: Objects with such wire already selected. Don't allow to select this object.";
214             return false;
215           }
216
217           aSelectedWiresFromObjects.bind(aWire, aWire);
218           aSelectedSketchesFromObjects.insert(aResultConstruction);
219         }
220       }
221     }
222   }
223
224   return true;
225 }
226
227 //==================================================================================================
228 bool FeaturesPlugin_ValidatorBaseForGeneration::isValidAttribute(const AttributePtr& theAttribute,
229                                                         const std::list<std::string>& theArguments,
230                                                         Events_InfoMessage& theError) const
231 {
232   if(!theAttribute.get()) {
233     theError = "Error: Empty attribute.";
234     return false;
235   }
236
237   std::string anAttributeType = theAttribute->attributeType();
238   if(anAttributeType == ModelAPI_AttributeSelectionList::typeId()) {
239     AttributeSelectionListPtr aListAttr =
240       std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
241     for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
242       // If at least one attribute is invalid, the result is false.
243       if(!isValidAttribute(aListAttr->value(anIndex), theArguments, theError)) {
244         return false;
245       }
246     }
247   } else if(anAttributeType == ModelAPI_AttributeSelection::typeId()) {
248     // Getting context.
249     AttributeSelectionPtr anAttr =
250       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
251     ResultPtr aContext = anAttr->context();
252     if(!aContext.get()) {
253       theError = "Error: Attribute have empty context.";
254       return false;
255     }
256
257     GeomShapePtr aShape = anAttr->value();
258     GeomShapePtr aContextShape = aContext->shape();
259     if(!aShape.get()) {
260       aShape = aContextShape;
261     }
262     if(!aShape.get()) {
263       theError = "Error: Empty shape selected";
264       return false;
265     }
266
267     ResultConstructionPtr aConstruction =
268       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
269     if(aConstruction.get()) {
270       // Construciotn selected. Check that is is not infinite.
271       if(aConstruction->isInfinite()) {
272         theError = "Error: Infinite constructions is not allowed as base.";
273         return false;
274       }
275
276       if(aShape->isEqual(aContextShape)) {
277         // Whole construction selected. Check that it have faces.
278         if(aConstruction->facesNum() > 0) {
279           return true;
280         }
281       } else {
282         // Shape on construction selected. Check that it is a face or wire.
283         if(aShape->shapeType() == GeomAPI_Shape::WIRE ||
284            aShape->shapeType() == GeomAPI_Shape::FACE) {
285           return true;
286         }
287       }
288
289       return false;
290     }
291
292     if(!aShape->isEqual(aContextShape)) {
293       // Local selection on body does not allowed.
294       theError =
295         "Error: Selected shape is in the local selection. Only global selection is allowed.";
296       return false;
297     }
298
299     // Check that object is a shape with allowed type.
300     GeomValidators_ShapeType aShapeTypeValidator;
301     if(!aShapeTypeValidator.isValid(anAttr, theArguments, theError)) {
302       theError = "Error: Selected shape has unacceptable type. Acceptable types are: faces or "
303                  "wires on sketch, whole sketch(if it has at least one face), "
304                  "and whole objects with shape types: %1";
305       std::string anArgumentString;
306       for(auto anIt = theArguments.cbegin(); anIt != theArguments.cend(); ++anIt) {
307         if (!anArgumentString.empty())
308           anArgumentString += ", ";
309         anArgumentString += *anIt;
310       }
311       theError.arg(anArgumentString);
312       return false;
313     }
314
315   } else {
316     theError = "Error: Attribute \"%1\" does not supported by this validator.";
317     theError.arg(anAttributeType);
318     return false;
319   }
320
321   return true;
322 }
323
324 //==================================================================================================
325 bool FeaturesPlugin_ValidatorCompositeLauncher::isValid(const AttributePtr& theAttribute,
326                                                         const std::list<std::string>& theArguments,
327                                                         Events_InfoMessage& theError) const
328 {
329   if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) {
330     theError = "Error: The attribute with the %1 type is not processed";
331     theError.arg(theAttribute->attributeType());
332     return false;
333   }
334   if (theArguments.size() != 2) {
335     theError = "Error: Wrong parameters in XML definition for %1 type";
336     theError.arg(theAttribute->attributeType());
337     return false;
338   }
339   // first argument is for the base attribute, second - for skipping feature kind
340   std::list<std::string>::const_iterator anIt = theArguments.begin();
341   std::string aBaseAttributeId = *anIt;
342   FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
343   AttributePtr aBaseAttribute = aFeature->attribute(aBaseAttributeId);
344   if (!aBaseAttribute.get()) {
345     theError = "Wrong parameters in XML definition for %1 type";
346     theError.arg(theAttribute->attributeType());
347     return false;
348   }
349   if (aBaseAttribute->isInitialized()) // when base list of composite feature is already filled,
350     // this validator is not necessary anymore
351     return true;
352
353   anIt++;
354   std::string aFeatureAttributeKind = *anIt;
355   GeomValidators_FeatureKind* aValidator = new GeomValidators_FeatureKind();
356   // check whether the selection is on the sketch
357   std::list<std::string> anArguments;
358   anArguments.push_back(aFeatureAttributeKind);
359
360   bool aFeatureKind = aValidator->isValid(theAttribute, theArguments, theError);
361   bool aPlanarFace = false;
362   // check if selection has Face selected
363   GeomValidators_ShapeType* aShapeType = new GeomValidators_ShapeType();
364   anArguments.clear();
365   anArguments.push_back("face");
366   aPlanarFace = aShapeType->isValid(theAttribute, anArguments, theError);
367
368   bool aValid = !aFeatureKind && aPlanarFace;
369   return aValid;
370 }
371
372 //==================================================================================================
373 bool FeaturesPlugin_ValidatorExtrusionDir::isValid(
374                                                const std::shared_ptr<ModelAPI_Feature>& theFeature,
375                                                const std::list<std::string>& theArguments,
376                                                Events_InfoMessage& theError) const
377 {
378   if(theArguments.size() != 2) {
379     theError = "Error: Validator should be used with 2 parameters for extrusion.";
380     return false;
381   }
382
383   std::list<std::string>::const_iterator
384     anArgsIt = theArguments.begin(), aLast = theArguments.end();
385
386   AttributePtr aCheckAttribute = theFeature->attribute(*anArgsIt);
387   ++anArgsIt;
388
389   GeomShapePtr aDirShape;
390   AttributeSelectionPtr aSelAttr = theFeature->selection(*anArgsIt);
391   if(aSelAttr.get()) {
392     aDirShape = aSelAttr->value();
393     if(!aDirShape.get()) {
394       ResultPtr aContext = aSelAttr->context();
395       if(aContext.get()) {
396         aDirShape = aContext->shape();
397       }
398     }
399   }
400
401   if(!aDirShape.get()) {
402     // Check that dir can be empty.
403     if(!isShapesCanBeEmpty(aCheckAttribute, theError)) {
404       theError = "Error: Base objects list contains vertex or edge, so attribute \"%1\" "
405                  "can not be used with default value. Select direction for extrusion.";
406       theError.arg(*anArgsIt);
407       return false;
408     } else {
409       return true;
410     }
411   }
412
413   std::shared_ptr<GeomAPI_Edge> aDirEdge(new GeomAPI_Edge(aDirShape));
414
415   // If faces selected check that direction not parallel with them.
416   AttributeSelectionListPtr aListAttr =
417     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(aCheckAttribute);
418   for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
419     AttributeSelectionPtr anAttr = aListAttr->value(anIndex);
420     GeomShapePtr aShapeInList = anAttr->value();
421     if(!aShapeInList.get()) {
422       aShapeInList = anAttr->context()->shape();
423     }
424     bool isParallel = true;
425     if(aShapeInList->shapeType() == GeomAPI_Shape::FACE ||
426        aShapeInList->shapeType() == GeomAPI_Shape::SHELL) {
427       for(GeomAPI_ShapeExplorer
428           anExp(aShapeInList, GeomAPI_Shape::FACE); anExp.more(); anExp.next()) {
429         std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(anExp.current()));
430         isParallel = GeomAlgoAPI_ShapeTools::isParallel(aDirEdge, aFace);
431         if(isParallel) {
432           break;
433         }
434       }
435     } else if(aShapeInList->shapeType() == GeomAPI_Shape::COMPOUND) {
436       std::shared_ptr<GeomAPI_PlanarEdges> aPlanarEdges =
437         std::dynamic_pointer_cast<GeomAPI_PlanarEdges>(aShapeInList);
438       if(aPlanarEdges.get()) {
439         std::shared_ptr<GeomAPI_Dir> aSketchDir = aPlanarEdges->norm();
440         if(aDirEdge->isLine()) {
441           std::shared_ptr<GeomAPI_Dir> aDir = aDirEdge->line()->direction();
442           isParallel = fabs(aSketchDir->angle(aDir) - M_PI / 2.0) < 10e-7;
443         } else {
444           isParallel = false;
445         }
446       } else {
447         isParallel = false;
448       }
449     } else {
450       isParallel = false;
451     }
452     if(isParallel) {
453       theError =
454         "Error: Direction is parallel to one of the selected face or face on selected shell.";
455       return false;
456     }
457   }
458
459   return true;
460 }
461
462 //==================================================================================================
463 bool FeaturesPlugin_ValidatorExtrusionDir::isNotObligatory(std::string theFeature,
464                                                            std::string theAttribute)
465 {
466   return false;
467 }
468
469 //==================================================================================================
470 bool FeaturesPlugin_ValidatorExtrusionDir::isShapesCanBeEmpty(const AttributePtr& theAttribute,
471                                                               Events_InfoMessage& theError) const
472 {
473   if(!theAttribute.get()) {
474     return true;
475   }
476
477   std::string anAttributeType = theAttribute->attributeType();
478   if(anAttributeType == ModelAPI_AttributeSelectionList::typeId()) {
479     AttributeSelectionListPtr aListAttr =
480       std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
481     for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
482       // If at least one attribute is invalid, the result is false.
483       if(!isShapesCanBeEmpty(aListAttr->value(anIndex), theError)) {
484         return false;
485       }
486     }
487   } else if(anAttributeType == ModelAPI_AttributeSelection::typeId()) {
488     // Getting context.
489     AttributeSelectionPtr anAttr =
490       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
491     ResultPtr aContext = anAttr->context();
492     if(!aContext.get()) {
493       return false;
494     }
495
496     GeomShapePtr aShape = anAttr->value();
497     GeomShapePtr aContextShape = aContext->shape();
498     if(!aShape.get()) {
499       aShape = aContextShape;
500     }
501     if(!aShape.get()) {
502       return false;
503     }
504
505     if(aShape->shapeType() == GeomAPI_Shape::VERTEX ||
506        aShape->shapeType() == GeomAPI_Shape::EDGE ||
507        !aShape->isPlanar()) {
508       return false;
509     }
510   } else {
511     return false;
512   }
513
514   return true;
515 }
516
517 //==================================================================================================
518 bool FeaturesPlugin_ValidatorBooleanSelection::isValid(const AttributePtr& theAttribute,
519                                                        const std::list<std::string>& theArguments,
520                                                        Events_InfoMessage& theError) const
521 {
522   AttributeSelectionListPtr anAttrSelectionList =
523     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
524   if(!anAttrSelectionList.get()) {
525     theError =
526       "Error: This validator can only work with selection list attributes in \"Boolean\" feature.";
527     return false;
528   }
529   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
530   int anOperationType = aFeature->integer("bool_type")->value();
531
532   for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) {
533     AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex);
534     if(!anAttrSelection.get()) {
535       theError = "Error: Empty attribute selection.";
536       return false;
537     }
538     ResultPtr aContext = anAttrSelection->context();
539     if(!aContext.get()) {
540       theError = "Error: Empty selection context.";
541       return false;
542     }
543     ResultConstructionPtr aResultConstruction =
544       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
545     if(aResultConstruction.get()) {
546       theError = "Error: Result construction not allowed for selection.";
547       return false;
548     }
549     std::shared_ptr<GeomAPI_Shape> aShape = anAttrSelection->value();
550     GeomShapePtr aContextShape = aContext->shape();
551     if(!aShape.get()) {
552       aShape = aContextShape;
553     }
554     if(!aShape.get()) {
555       theError = "Error: Empty shape.";
556       return false;
557     }
558     if(!aShape->isEqual(aContextShape)) {
559       theError = "Error: Local selection not allowed.";
560       return false;
561     }
562
563     int aShapeType = aShape->shapeType();
564     if(anOperationType == 1) {
565       // Fuse operation. Allow to select edges, faces and solids.
566       if(aShapeType != GeomAPI_Shape::EDGE &&
567          aShapeType != GeomAPI_Shape::FACE &&
568          aShapeType != GeomAPI_Shape::SOLID &&
569          aShapeType != GeomAPI_Shape::COMPSOLID &&
570          aShapeType != GeomAPI_Shape::COMPOUND) {
571         theError = "Error: Selected shape has the wrong type.";
572         return false;
573       }
574     } else {
575       if(aShapeType != GeomAPI_Shape::SOLID &&
576          aShapeType != GeomAPI_Shape::COMPSOLID &&
577          aShapeType != GeomAPI_Shape::COMPOUND) {
578         theError = "Error: Selected shape has the wrong type.";
579         return false;
580       }
581     }
582   }
583
584   return true;
585 }
586
587 //==================================================================================================
588 bool FeaturesPlugin_ValidatorPartitionSelection::isValid(const AttributePtr& theAttribute,
589                                                        const std::list<std::string>& theArguments,
590                                                        Events_InfoMessage& theError) const
591 {
592   AttributeSelectionListPtr anAttrSelectionList =
593     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
594   if(!anAttrSelectionList.get()) {
595     theError = "Error: This validator can only work with selection list in \"Partition\" feature.";
596     return false;
597   }
598
599   for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) {
600     AttributeSelectionPtr aSelectAttr = anAttrSelectionList->value(anIndex);
601
602     //GeomValidators_BodyShapes aBodyValidator;
603     //if(aBodyValidator.isValid(aSelectAttr, theArguments, theError)) {
604     //  continue;
605     //}
606
607     GeomValidators_FeatureKind aFeatureKindValidator;
608     if(aFeatureKindValidator.isValid(aSelectAttr, theArguments, theError)) {
609       continue;
610     }
611
612     ResultPtr aContext = aSelectAttr->context();
613     ResultConstructionPtr aResultConstruction =
614       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
615     if(aResultConstruction.get()) {
616       theError = "Error: Only body shapes and construction planes are allowed for selection.";
617       return false;
618     }
619
620     ResultCompSolidPtr aResultCompsolid =
621       std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aContext);
622     if(aResultCompsolid.get()) {
623       continue;
624     }
625
626     theError = "Error: Only body shapes and construction planes are allowed for selection.";
627     return false;
628   }
629
630   theError = "";
631   return true;
632 }
633
634 //==================================================================================================
635 bool FeaturesPlugin_ValidatorRemoveSubShapesSelection::isValid(const AttributePtr& theAttribute,
636                                                      const std::list<std::string>& theArguments,
637                                                      Events_InfoMessage& theError) const
638 {
639   AttributeSelectionListPtr aSubShapesAttrList =
640     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
641   if(!aSubShapesAttrList.get()) {
642     theError =
643       "Error: This validator can only work with selection list in \"Remove Sub-Shapes\" feature.";
644     return false;
645   }
646
647   static const std::string aBaseShapeID = "base_shape";
648   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
649   AttributeSelectionPtr aShapeAttrSelection = aFeature->selection(aBaseShapeID);
650
651   if(!aShapeAttrSelection.get()) {
652     theError = "Error: Could not get \"%1\" attribute.";
653     theError.arg(aBaseShapeID);
654     return false;
655   }
656
657   GeomShapePtr aBaseShape = aShapeAttrSelection->value();
658   ResultPtr aContext = aShapeAttrSelection->context();
659   if(!aContext.get()) {
660     theError = "Error: Empty context.";
661     return false;
662   }
663   if(!aBaseShape.get()) {
664     aBaseShape = aContext->shape();
665   }
666   if(!aBaseShape.get()) {
667     theError = "Error: Empty base shape.";
668     return false;
669   }
670
671   for(int anIndex = 0; anIndex < aSubShapesAttrList->size(); ++anIndex) {
672     bool isSameFound = false;
673     AttributeSelectionPtr anAttrSelectionInList = aSubShapesAttrList->value(anIndex);
674     GeomShapePtr aShapeToAdd = anAttrSelectionInList->value();
675     for(GeomAPI_ShapeIterator anIt(aBaseShape); anIt.more(); anIt.next()) {
676       if(anIt.current()->isEqual(aShapeToAdd)) {
677         isSameFound = true;
678         break;
679       }
680     }
681     if(!isSameFound) {
682       theError = "Error: Only sub-shapes of selected shape is allowed for selection.";
683       return false;
684     }
685   }
686
687   return true;
688 }
689
690 //==================================================================================================
691 bool FeaturesPlugin_ValidatorRemoveSubShapesResult::isValid(
692   const std::shared_ptr<ModelAPI_Feature>& theFeature,
693   const std::list<std::string>& theArguments,
694   Events_InfoMessage& theError) const
695 {
696   static const std::string aBaseShapeID = "base_shape";
697   static const std::string aSubShapesID = "subshapes";
698
699   if(theFeature->getKind() != "Remove_SubShapes") {
700     theError = "Error: Feature \"%1\" does not supported by this validator.";
701     theError.arg(theFeature->getKind());
702     return false;
703   }
704
705   AttributeSelectionPtr aShapeAttrSelection = theFeature->selection(aBaseShapeID);
706   if(!aShapeAttrSelection.get()) {
707     theError = "Error: Could not get \"%1\" attribute.";
708     theError.arg(aBaseShapeID);
709     return false;
710   }
711
712   AttributeSelectionListPtr aSubShapesAttrList = theFeature->selectionList(aSubShapesID);
713   if(!aSubShapesAttrList.get()) {
714     theError = "Error: Could not get \"%1\" attribute.";
715     theError.arg(aSubShapesID);
716     return false;
717   }
718
719   // Copy base shape.
720   GeomShapePtr aBaseShape = aShapeAttrSelection->value();
721   if(!aBaseShape.get()) {
722     theError = "Error: Base shape is empty.";
723     return false;
724   }
725   GeomShapePtr aResultShape = aBaseShape->emptyCopied();
726
727   // Copy sub-shapes from list to new shape.
728   for(int anIndex = 0; anIndex < aSubShapesAttrList->size(); ++anIndex) {
729     AttributeSelectionPtr anAttrSelectionInList = aSubShapesAttrList->value(anIndex);
730     GeomShapePtr aShapeToAdd = anAttrSelectionInList->value();
731     GeomAlgoAPI_ShapeBuilder::add(aResultShape, aShapeToAdd);
732   }
733
734   // Check new shape.
735   if(!GeomAlgoAPI_ShapeTools::isShapeValid(aResultShape)) {
736     theError = "Error: Resulting shape is not valid.";
737     return false;
738   }
739
740   return true;
741 }
742
743 //==================================================================================================
744 bool FeaturesPlugin_ValidatorRemoveSubShapesResult::isNotObligatory(std::string theFeature,
745                                                                     std::string theAttribute)
746 {
747   return false;
748 }
749
750 //==================================================================================================
751 bool FeaturesPlugin_ValidatorUnionSelection::isValid(const AttributePtr& theAttribute,
752                                                      const std::list<std::string>& theArguments,
753                                                      Events_InfoMessage& theError) const
754 {
755   AttributeSelectionListPtr aBaseObjectsAttrList =
756     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
757   if(!aBaseObjectsAttrList.get()) {
758     theError = "Error: This validator can only work with selection list in \"%1\" feature.";
759     theError.arg(FeaturesPlugin_Union::ID());
760     return false;
761   }
762
763   for(int anIndex = 0; anIndex < aBaseObjectsAttrList->size(); ++anIndex) {
764     bool isSameFound = false;
765     AttributeSelectionPtr anAttrSelectionInList = aBaseObjectsAttrList->value(anIndex);
766     ResultCompSolidPtr aResult =
767       std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(anAttrSelectionInList->context());
768     if(!aResult.get()) {
769       continue;
770     }
771     if(aResult->numberOfSubs() > 0) {
772       theError = "Error: Whole compsolids not allowed for selection.";
773       return false;
774     }
775   }
776
777   return true;
778 }
779
780 //==================================================================================================
781 bool FeaturesPlugin_ValidatorUnionArguments::isValid(
782   const std::shared_ptr<ModelAPI_Feature>& theFeature,
783   const std::list<std::string>& theArguments,
784   Events_InfoMessage& theError) const
785 {
786   // Check feature kind.
787   if(theFeature->getKind() != FeaturesPlugin_Union::ID()) {
788     theError = "Error: This validator supports only \"%1\" feature.";
789     theError.arg(FeaturesPlugin_Union::ID());
790     return false;
791   }
792
793   // Get base objects attribute list.
794   AttributeSelectionListPtr aBaseObejctsAttrList =
795     theFeature->selectionList(FeaturesPlugin_Union::BASE_OBJECTS_ID());
796   if(!aBaseObejctsAttrList.get()) {
797     theError = "Error: Could not get \"%1\" attribute.";
798     theError.arg(FeaturesPlugin_Union::BASE_OBJECTS_ID());
799     return false;
800   }
801
802   // Get all shapes.
803   ListOfShape aBaseShapesList;
804   for(int anIndex = 0; anIndex < aBaseObejctsAttrList->size(); ++anIndex) {
805     AttributeSelectionPtr anAttrSelectionInList = aBaseObejctsAttrList->value(anIndex);
806     GeomShapePtr aShape = anAttrSelectionInList->value();
807     aBaseShapesList.push_back(aShape);
808   }
809
810   // Make componud and find connected.
811   GeomShapePtr aCompound = GeomAlgoAPI_CompoundBuilder::compound(aBaseShapesList);
812   ListOfShape aCombined, aFree;
813   GeomAlgoAPI_ShapeTools::combineShapes(aCompound, GeomAPI_Shape::COMPSOLID, aCombined, aFree);
814
815   if(aFree.size() > 0 || aCombined.size() > 1) {
816     theError = "Error: Not all shapes have shared topology.";
817     return false;
818   }
819
820   return true;
821 }
822
823 //==================================================================================================
824 bool FeaturesPlugin_ValidatorUnionArguments::isNotObligatory(std::string theFeature,
825                                                              std::string theAttribute)
826 {
827   return false;
828 }
829
830 bool FeaturesPlugin_ValidatorConcealedResult::isValid(const AttributePtr& theAttribute,
831                                             const std::list<std::string>& theArguments,
832                                             Events_InfoMessage& theError) const
833 {
834   if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) {
835     theError = "Error: The attribute with the %1 type is not processed";
836     theError.arg(theAttribute->attributeType());
837     return false;
838   }
839
840   AttributeReferencePtr aRefAttribute = std::dynamic_pointer_cast<ModelAPI_AttributeReference>
841                                                                                (theAttribute);
842   ObjectPtr aRefObject = aRefAttribute->value();
843   if (!aRefObject.get()) {
844     theError = "Error: Empty feature.";
845     return false;
846   }
847
848   FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aRefObject);
849   if (!aRefFeature.get()) {
850     theError = "Error: Empty feature.";
851     return false;
852   }
853   std::list<std::shared_ptr<ModelAPI_Result> > aResults;
854   ModelAPI_Tools::getConcealedResults(aRefFeature, aResults);
855
856   size_t aConcealedResults = aResults.size();
857   if (!aConcealedResults && !theArguments.empty()) {
858     // find if these results are touched by the feature in another attribute
859     std::list<std::string>::const_iterator anIt = theArguments.begin();
860     std::string aRecoveredList = *anIt;
861     if (!aRecoveredList.empty()) {
862       std::shared_ptr<ModelAPI_AttributeRefList> aParameterList =
863                                  theAttribute->owner()->data()->reflist(aRecoveredList);
864       if (aParameterList.get())
865         aConcealedResults = aParameterList->size();
866     }
867   }
868
869   if (aConcealedResults == 0)
870     theError = "Error: No concealed results.";
871
872   return theError.empty();
873 }