Salome HOME
IPAL53870: Dump study script creates an excess sub-mesh
[modules/smesh.git] / src / SMESH_I / SMESH_Filter_i.hxx
1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
24 //  File   : SMESH_Filter_i.hxx
25 //  Author : Alexey Petrov, OCC
26 //  Module : SMESH
27
28 #ifndef _SMESH_FILTER_I_HXX_
29 #define _SMESH_FILTER_I_HXX_
30
31 #include "SMESH.hxx"
32
33 #include <SALOMEconfig.h>
34 #include CORBA_SERVER_HEADER(SMESH_Filter)
35
36 #include <LDOM_Document.hxx>
37 #include <TopoDS_Shape.hxx>
38
39 #include "SALOME_GenericObj_i.hh"
40 #include "SMESH_ControlsDef.hxx"
41
42 #include <list>
43
44 class SMESH_GroupBase_i;
45
46
47 namespace SMESH
48 {
49   /*!
50    * \brief Object notified on change of base objects and
51    *        notifying dependent objects in its turn.
52    *        This interface is used to track the following dependencies:
53    *        - GroupOnFiler depending on Filter predicates
54    *        - Filter depending on a Group via FT_BelongToMeshGroup predicate 
55    */
56   struct NotifyerAndWaiter
57   {
58     virtual void OnBaseObjModified(NotifyerAndWaiter* obj, bool removed) {};
59     // specific reaction on modification of a base object
60
61     void Modified( bool removed=false, NotifyerAndWaiter* who = 0);
62     // calls OnBaseObjModified(), if who != 0, and myWaiters[i]->Modified(who)
63
64     void AddModifWaiter    ( NotifyerAndWaiter* waiter ); // adds a dependent object to notify
65     void RemoveModifWaiter ( NotifyerAndWaiter* waiter ); // CALL IT when a waiter dies!!!
66     bool ContainModifWaiter( NotifyerAndWaiter* waiter );
67     std::list<NotifyerAndWaiter*> myWaiters;
68   };
69   // ================================================================================
70   /*
71     FUNCTORS
72   */
73   
74   /*
75     Class       : Functor_i
76     Description : An abstact class for all functors 
77   */
78   class SMESH_I_EXPORT Functor_i: public virtual POA_SMESH::Functor,
79                                   public virtual SALOME::GenericObj_i
80   {
81   public:
82     virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
83     Controls::FunctorPtr            GetFunctor() { return myFunctorPtr; }
84     ElementType                     GetElementType();
85
86   protected:
87     Functor_i();
88     ~Functor_i();
89   protected:                                
90     Controls::FunctorPtr            myFunctorPtr;
91   };
92   
93   /*
94     Class       : NumericalFunctor_i
95     Description : Base class for numerical functors 
96   */
97   class SMESH_I_EXPORT NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
98                                            public virtual Functor_i
99   {
100   public:
101     CORBA::Double                   GetValue( CORBA::Long theElementId );
102     SMESH::Histogram*               GetHistogram(CORBA::Short   nbIntervals,
103                                                  CORBA::Boolean isLogarithmic);
104     SMESH::Histogram*               GetLocalHistogram(CORBA::Short               nbIntervals,
105                                                       CORBA::Boolean            isLogarithmic,
106                                                       SMESH::SMESH_IDSource_ptr object);
107     void                            SetPrecision( CORBA::Long thePrecision );
108     CORBA::Long                     GetPrecision();
109     Controls::NumericalFunctorPtr   GetNumericalFunctor();
110     
111   protected:
112     Controls::NumericalFunctorPtr   myNumericalFunctorPtr;
113   };
114   
115   
116   /*
117     Class       : SMESH_MinimumAngleFunct
118     Description : Functor for calculation of minimum angle
119   */
120   class SMESH_I_EXPORT MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
121                                        public virtual NumericalFunctor_i
122   {
123   public:
124     MinimumAngle_i();
125     FunctorType                     GetFunctorType();
126   };
127   
128   
129   /*
130     Class       : AspectRatio_i
131     Description : Functor for calculating aspect ratio
132   */
133   class SMESH_I_EXPORT AspectRatio_i: public virtual POA_SMESH::AspectRatio,
134                                       public virtual NumericalFunctor_i
135   {
136   public:
137     AspectRatio_i();
138     FunctorType                     GetFunctorType();
139   };
140   
141   
142   /*
143     Class       : AspectRatio3D_i
144     Description : Functor for calculating aspect ratio for 3D
145   */
146   class SMESH_I_EXPORT AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
147                                         public virtual NumericalFunctor_i
148   {
149   public:
150     AspectRatio3D_i();
151     FunctorType                     GetFunctorType();
152   };
153   
154
155   /*
156     Class       : Warping_i
157     Description : Functor for calculating warping
158   */
159   class SMESH_I_EXPORT Warping_i: public virtual POA_SMESH::Warping,
160                                   public virtual NumericalFunctor_i
161   {
162   public:
163     Warping_i();
164     FunctorType                     GetFunctorType();
165   };
166   
167   
168   /*
169     Class       : Taper_i
170     Description : Functor for calculating taper
171   */
172   class SMESH_I_EXPORT Taper_i: public virtual POA_SMESH::Taper,
173                                 public virtual NumericalFunctor_i
174   {
175   public:
176     Taper_i();
177     FunctorType                     GetFunctorType();
178   };
179   
180   
181   /*
182     Class       : Skew_i
183     Description : Functor for calculating skew in degrees
184   */
185   class SMESH_I_EXPORT Skew_i: public virtual POA_SMESH::Skew,
186                                public virtual NumericalFunctor_i
187   {
188   public:
189     Skew_i();
190     FunctorType                     GetFunctorType();
191   };
192   
193   
194   /*
195     Class       : Area_i
196     Description : Functor for calculating area
197   */
198   class SMESH_I_EXPORT Area_i: public virtual POA_SMESH::Area,
199                                public virtual NumericalFunctor_i
200   {
201   public:
202     Area_i();
203     FunctorType                     GetFunctorType();
204   };
205   
206   
207   /*
208     Class       : Volume3D_i
209     Description : Functor for calculating volume of 3D element
210   */
211   class SMESH_I_EXPORT Volume3D_i: public virtual POA_SMESH::Volume3D,
212                                    public virtual NumericalFunctor_i
213   {
214   public:
215     Volume3D_i();
216     FunctorType                     GetFunctorType();
217   };
218   
219   
220   /*
221     Class       : MaxElementLength2D_i
222     Description : Functor for calculating maximum length of 2D element
223   */
224   class SMESH_I_EXPORT MaxElementLength2D_i: public virtual POA_SMESH::MaxElementLength2D,
225                                              public virtual NumericalFunctor_i
226   {
227   public:
228     MaxElementLength2D_i();
229     FunctorType                     GetFunctorType();
230   };
231   
232   
233   /*
234     Class       : MaxElementLength3D_i
235     Description : Functor for calculating maximum length of 3D element
236   */
237   class SMESH_I_EXPORT MaxElementLength3D_i: public virtual POA_SMESH::MaxElementLength3D,
238                                              public virtual NumericalFunctor_i
239   {
240   public:
241     MaxElementLength3D_i();
242     FunctorType                     GetFunctorType();
243   };
244   
245   
246   /*
247     Class       : Length_i
248     Description : Functor for calculating length of edge
249   */
250   class SMESH_I_EXPORT Length_i: public virtual POA_SMESH::Length,
251                                  public virtual NumericalFunctor_i
252   {
253   public:
254     Length_i();
255     FunctorType                     GetFunctorType();
256   };
257   
258   /*
259     Class       : Length2D_i
260     Description : Functor for calculating length of edge
261   */
262   class SMESH_I_EXPORT Length2D_i: public virtual POA_SMESH::Length2D,
263                                    public virtual NumericalFunctor_i
264   {
265   public:
266     Length2D_i();
267     SMESH::Length2D::Values*        GetValues();
268     FunctorType                     GetFunctorType();
269     
270   protected:
271     Controls::Length2DPtr          myLength2DPtr;
272   };
273   
274   /*
275     Class       : MultiConnection_i
276     Description : Functor for calculating number of faces conneted to the edge
277   */
278   class SMESH_I_EXPORT MultiConnection_i: public virtual POA_SMESH::MultiConnection,
279                                           public virtual NumericalFunctor_i
280   {
281   public:
282     MultiConnection_i();
283     FunctorType                     GetFunctorType();
284   };
285   
286   /*
287     Class       : MultiConnection2D_i
288     Description : Functor for calculating number of faces conneted to the edge
289   */
290   class SMESH_I_EXPORT MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
291                                             public virtual NumericalFunctor_i
292   {
293   public:
294     MultiConnection2D_i();
295     SMESH::MultiConnection2D::Values*  GetValues();
296     FunctorType                        GetFunctorType();
297     
298   protected:
299     Controls::MultiConnection2DPtr     myMulticonnection2DPtr;
300   };
301   
302   /*
303     Class       : BallDiameter_i
304     Description : Functor returning diameter of a ball element
305   */
306   class SMESH_I_EXPORT BallDiameter_i: public virtual POA_SMESH::BallDiameter,
307                                        public virtual NumericalFunctor_i
308   {
309   public:
310     BallDiameter_i();
311     FunctorType                     GetFunctorType();
312   };
313   
314   /*
315     Class       : NodeConnectivityNumber_i
316     Description : Functor returning diameter of a ball element
317   */
318   class SMESH_I_EXPORT NodeConnectivityNumber_i: public virtual POA_SMESH::NodeConnectivityNumber,
319                                        public virtual NumericalFunctor_i
320   {
321   public:
322     NodeConnectivityNumber_i();
323     FunctorType                     GetFunctorType();
324   };
325   
326   
327   /*
328     PREDICATES
329   */
330   /*
331     Class       : Predicate_i
332     Description : Base class for all predicates
333   */
334   class SMESH_I_EXPORT Predicate_i: public virtual POA_SMESH::Predicate,
335                                     public virtual Functor_i
336   {
337   public:
338     CORBA::Boolean                  IsSatisfy( CORBA::Long theElementId );
339     CORBA::Long                     NbSatisfying( SMESH::SMESH_IDSource_ptr obj );
340     Controls::PredicatePtr          GetPredicate();
341     
342   protected:
343     Controls::PredicatePtr          myPredicatePtr;
344   };
345   
346   
347   /*
348     Class       : BadOrientedVolume_i
349     Description : Verify whether a mesh volume is incorrectly oriented from
350     the point of view of MED convention
351   */
352   class SMESH_I_EXPORT BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
353                                             public virtual Predicate_i
354   {
355   public:
356     BadOrientedVolume_i();
357     FunctorType                     GetFunctorType();
358   };
359   
360   /*
361     Class       : BareBorderVolume_i
362     Description : Verify whether a mesh volume has a free facet without a face on it
363   */
364   class SMESH_I_EXPORT BareBorderVolume_i: public virtual POA_SMESH::BareBorderVolume,
365                                            public virtual Predicate_i
366   {
367   public:
368     BareBorderVolume_i();
369     FunctorType                     GetFunctorType();
370   };
371   
372   /*
373     Class       : BareBorderFace_i
374     Description : Verify whether a mesh face has a free border without an edge on it
375   */
376   class SMESH_I_EXPORT BareBorderFace_i: public virtual POA_SMESH::BareBorderFace,
377                                          public virtual Predicate_i
378   {
379   public:
380     BareBorderFace_i();
381     FunctorType                     GetFunctorType();
382   };
383   
384   /*
385     Class       : OverConstrainedVolume_i
386     Description : Verify whether a mesh volume has only one facet shared with other volumes
387   */
388   class SMESH_I_EXPORT OverConstrainedVolume_i: public virtual POA_SMESH::OverConstrainedVolume,
389                                                 public virtual Predicate_i
390   {
391   public:
392     OverConstrainedVolume_i();
393     FunctorType                     GetFunctorType();
394   };
395   
396   /*
397     Class       : OverConstrainedFace_i
398     Description : Verify whether a mesh face has only one border shared with other faces
399   */
400   class SMESH_I_EXPORT OverConstrainedFace_i: public virtual POA_SMESH::OverConstrainedFace,
401                                               public virtual Predicate_i
402   {
403   public:
404     OverConstrainedFace_i();
405     FunctorType                     GetFunctorType();
406   };
407
408   /*
409     Class       : BelongToMeshGroup_i
410     Description : Verify whether a mesh element is included into a mesh group
411   */
412   class SMESH_I_EXPORT BelongToMeshGroup_i: public virtual POA_SMESH::BelongToMeshGroup,
413                                             public virtual Predicate_i
414   {
415     std::string                    myID; // IOR or StoreName
416     SMESH::SMESH_GroupBase_var     myGroup;
417     Controls::BelongToMeshGroupPtr myBelongToMeshGroup;
418   public:
419     BelongToMeshGroup_i();
420     ~BelongToMeshGroup_i();
421     void                       SetGroup( SMESH::SMESH_GroupBase_ptr theGroup );
422     void                       SetGroupID( const char* theID ); // IOR or StoreName
423     SMESH::SMESH_GroupBase_ptr GetGroup();
424
425     std::string                GetGroupID();
426     FunctorType                GetFunctorType();
427     //virtual void               SetMesh( SMESH_Mesh_ptr theMesh );
428   };
429
430   /*
431     Class       : BelongToGeom_i
432     Description : Predicate for selection on geometrical support
433   */
434   class SMESH_I_EXPORT BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
435                                        public virtual Predicate_i
436   {
437   public:
438     BelongToGeom_i();
439     virtual                         ~BelongToGeom_i();
440     
441     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
442     void                            SetElementType( ElementType theType );
443     FunctorType                     GetFunctorType();
444     
445     void                            SetGeom( const TopoDS_Shape& theShape );
446     
447     void                            SetShapeName( const char* theName );
448     void                            SetShape( const char* theID, const char* theName );
449     char*                           GetShapeName();
450     char*                           GetShapeID();
451
452     void                            SetTolerance( CORBA::Double );
453     CORBA::Double                   GetTolerance();
454     
455   protected:
456     Controls::BelongToGeomPtr       myBelongToGeomPtr;
457     char*                           myShapeName;
458     char*                           myShapeID;
459   };
460   
461   /*
462     Class       : BelongToSurface_i
463     Description : Verify whether mesh element lie in pointed Geom planar object
464   */
465   class SMESH_I_EXPORT BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
466                                           public virtual Predicate_i
467   {
468   public:
469     BelongToSurface_i( const Handle(Standard_Type)& );
470     virtual                         ~BelongToSurface_i();
471     
472     void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
473     
474     void                            SetShapeName( const char* theName, ElementType theType );
475     void                            SetShape( const char* theID, const char* theName, ElementType theType );
476     char*                           GetShapeName();
477     char*                           GetShapeID();
478
479     void                            SetTolerance( CORBA::Double );
480     CORBA::Double                   GetTolerance();
481     
482     void                            SetUseBoundaries( CORBA::Boolean theUseBndRestrictions );
483     CORBA::Boolean                  GetUseBoundaries();
484
485   protected:
486     Controls::ElementsOnSurfacePtr  myElementsOnSurfacePtr;
487     char*                           myShapeName;
488     char*                           myShapeID;
489     Handle(Standard_Type)           mySurfaceType;
490   };
491   
492   /*
493     Class       : BelongToPlane_i
494     Description : Verify whether mesh element lie in pointed Geom planar object
495   */
496   class SMESH_I_EXPORT BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
497                                         public virtual BelongToSurface_i
498   {
499   public:
500     BelongToPlane_i();
501     void                            SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
502     FunctorType                     GetFunctorType();
503   };
504   
505   /*
506     Class       : BelongToCylinder_i
507     Description : Verify whether mesh element lie in pointed Geom cylindrical object
508   */
509   class SMESH_I_EXPORT BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
510                                            public virtual BelongToSurface_i
511   {
512   public:
513     BelongToCylinder_i();
514     void                            SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
515     FunctorType                     GetFunctorType();
516   };
517
518   /*
519     Class       : BelongToGenSurface_i
520     Description : Verify whether mesh element lie on pointed Geom surfasic object
521   */
522   class BelongToGenSurface_i: public virtual POA_SMESH::BelongToGenSurface,
523                               public virtual BelongToSurface_i
524   {
525   public:
526     BelongToGenSurface_i();
527     void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
528     FunctorType                     GetFunctorType();
529   };
530   
531   /*
532     Class       : LyingOnGeom_i
533     Description : Predicate for selection on geometrical support(lying or partially lying)
534   */
535   class SMESH_I_EXPORT LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
536                                       public virtual Predicate_i
537   {
538   public:
539     LyingOnGeom_i();
540     virtual                         ~LyingOnGeom_i();
541     
542     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
543     void                            SetElementType( ElementType theType );
544     FunctorType                     GetFunctorType();
545     
546     void                            SetGeom( const TopoDS_Shape& theShape );
547     
548     void                            SetShapeName( const char* theName );
549     void                            SetShape( const char* theID, const char* theName );
550     char*                           GetShapeName();
551     char*                           GetShapeID();
552
553     void                            SetTolerance( CORBA::Double );
554     CORBA::Double                   GetTolerance();
555     
556   protected:
557     Controls::LyingOnGeomPtr        myLyingOnGeomPtr;
558     char*                           myShapeName;
559     char*                           myShapeID;
560   };
561   
562   /*
563     Class       : FreeBorders_i
564     Description : Predicate for free borders
565   */
566   class SMESH_I_EXPORT FreeBorders_i: public virtual POA_SMESH::FreeBorders,
567                                       public virtual Predicate_i
568   {
569   public:
570     FreeBorders_i();
571     FunctorType                     GetFunctorType();
572   };
573   
574   
575   /*
576     Class       : FreeEdges_i
577     Description : Predicate for free edges
578   */
579   class SMESH_I_EXPORT FreeEdges_i: public virtual POA_SMESH::FreeEdges,
580                                     public virtual Predicate_i
581   {
582   public:
583     FreeEdges_i();
584     SMESH::FreeEdges::Borders*      GetBorders();
585     FunctorType                     GetFunctorType();
586     
587   protected:
588     Controls::FreeEdgesPtr          myFreeEdgesPtr;
589   };
590   
591
592   /*
593     Class       : FreeFaces_i
594     Description : Predicate for free faces
595   */
596   class SMESH_I_EXPORT FreeFaces_i: public virtual POA_SMESH::FreeFaces,
597                                     public virtual Predicate_i
598   {
599   public:
600     FreeFaces_i();
601     FunctorType                     GetFunctorType();
602   };
603   
604
605   /*
606     Class       : FreeNodes_i
607     Description : Predicate for free nodes
608   */
609   class SMESH_I_EXPORT FreeNodes_i: public virtual POA_SMESH::FreeNodes,
610                                     public virtual Predicate_i
611   {
612   public:
613     FreeNodes_i();
614     FunctorType                     GetFunctorType();
615   };
616   
617   
618   /*
619     Class       : EqualNodes_i
620     Description : Predicate for equal nodes
621   */
622   class SMESH_I_EXPORT EqualNodes_i: public virtual POA_SMESH::EqualNodes,
623                                      public virtual Predicate_i
624   {
625   public:
626     EqualNodes_i();
627     FunctorType                     GetFunctorType();
628     void                            SetTolerance( double );
629     double                          GetTolerance();
630
631   private:
632     Controls::CoincidentNodesPtr myCoincidentNodesPtr;
633   };
634   /*
635     Class       : EqualEdges_i
636     Description : Predicate for equal edges
637   */
638   class SMESH_I_EXPORT EqualEdges_i: public virtual POA_SMESH::EqualEdges,
639                                      public virtual Predicate_i
640   {
641   public:
642     EqualEdges_i();
643     FunctorType                     GetFunctorType();
644   };
645   /*
646     Class       : EqualFaces_i
647     Description : Predicate for equal Faces
648   */
649   class SMESH_I_EXPORT EqualFaces_i: public virtual POA_SMESH::EqualFaces,
650                                      public virtual Predicate_i
651   {
652   public:
653     EqualFaces_i();
654     FunctorType                     GetFunctorType();
655   };
656   /*
657     Class       : EqualVolumes_i
658     Description : Predicate for equal Volumes
659   */
660   class SMESH_I_EXPORT EqualVolumes_i: public virtual POA_SMESH::EqualVolumes,
661                                        public virtual Predicate_i
662   {
663   public:
664     EqualVolumes_i();
665     FunctorType                     GetFunctorType();
666   };
667   
668   
669   /*
670     Class       : RangeOfIds_i
671     Description : Predicate for Range of Ids
672   */
673   class SMESH_I_EXPORT RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
674                                      public virtual Predicate_i
675   {
676   public:
677     RangeOfIds_i();
678     void                            SetRange( const SMESH::long_array& theIds );
679     CORBA::Boolean                  SetRangeStr( const char* theRange );
680     char*                           GetRangeStr();
681     
682     void                            SetElementType( ElementType theType );
683     FunctorType                     GetFunctorType();
684     
685   protected:
686     Controls::RangeOfIdsPtr         myRangeOfIdsPtr;
687   };
688
689   /*
690     Class       : LinearOrQuadratic_i
691     Description : Verify whether a mesh element is linear
692   */
693   class SMESH_I_EXPORT LinearOrQuadratic_i: public virtual POA_SMESH::LinearOrQuadratic,
694                                             public virtual Predicate_i
695   {
696   public:
697     LinearOrQuadratic_i();
698     FunctorType                    GetFunctorType();
699     void                           SetElementType( ElementType theType );
700
701   private:
702    Controls::LinearOrQuadraticPtr  myLinearOrQuadraticPtr;
703   };
704   
705   /*
706     Class       : GroupColor_i
707     Description : Functor for check color of group to whic mesh element belongs to
708   */
709   class SMESH_I_EXPORT GroupColor_i: public virtual POA_SMESH::GroupColor,
710                                      public virtual Predicate_i
711   {
712   public:
713     GroupColor_i();
714     FunctorType             GetFunctorType();
715
716     void                    SetElementType( ElementType theType );
717     void                    SetColorStr( const char* theColor );
718     char*                   GetColorStr();
719
720   private:
721     Controls::GroupColorPtr myGroupColorPtr;
722   };
723   
724   /*
725     Class       : ElemGeomType_i
726     Description : Functor for check element geometry type
727   */
728   class SMESH_I_EXPORT ElemGeomType_i: public virtual POA_SMESH::ElemGeomType,
729                                        public virtual Predicate_i
730   {
731   public:
732     ElemGeomType_i();
733     FunctorType             GetFunctorType();
734
735     void                    SetElementType ( ElementType  theType );
736     void                    SetGeometryType( GeometryType theType );
737     GeometryType            GetGeometryType() const;
738
739   private:
740     Controls::ElemGeomTypePtr myElemGeomTypePtr;
741   };
742
743   /*
744     Class       : ElemEntityType_i
745     Description : Functor for check element entity type
746   */
747   class SMESH_I_EXPORT ElemEntityType_i: public virtual POA_SMESH::ElemEntityType,
748                                          public virtual Predicate_i
749   {
750   public:
751     ElemEntityType_i();
752     FunctorType             GetFunctorType();
753
754     void                    SetElementType ( ElementType  theType );
755     void                    SetEntityType( EntityType theEntityType );
756     EntityType              GetEntityType() const;
757
758   private:
759     Controls::ElemEntityTypePtr myElemEntityTypePtr;
760   };
761   
762   /*
763     Class       : CoplanarFaces_i
764     Description : Returns true if a mesh face is a coplanar neighbour to a given one
765   */
766   class SMESH_I_EXPORT CoplanarFaces_i: public virtual POA_SMESH::CoplanarFaces,
767                                         public virtual Predicate_i
768   {
769   public:
770     CoplanarFaces_i();
771     FunctorType             GetFunctorType();
772
773     void                    SetFace ( CORBA::Long theFaceID );
774     void                    SetTolerance( CORBA::Double theToler );
775     char*                   GetFaceAsString () const;
776     CORBA::Long             GetFace () const;
777     CORBA::Double           GetTolerance () const;
778   private:
779     Controls::CoplanarFacesPtr myCoplanarFacesPtr;
780   };
781
782   /*
783    * Class       : ConnectedElements_i
784    * Description : Returns true if an element is connected via other elements to the element
785    *               located at a given point.
786    */
787   class SMESH_I_EXPORT ConnectedElements_i: public virtual POA_SMESH::ConnectedElements,
788                                             public virtual Predicate_i
789   {
790   public:
791     ConnectedElements_i();
792     FunctorType             GetFunctorType();
793
794     void                    SetElementType( ElementType theType );
795     void                    SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z );
796     void                    SetVertex( GEOM::GEOM_Object_ptr vertex )
797       throw (SALOME::SALOME_Exception);
798     void                    SetNode ( CORBA::Long nodeID )
799       throw (SALOME::SALOME_Exception);
800     void                    SetThreshold ( const char* threshold,
801                                            SMESH::ConnectedElements::ThresholdType type )
802       throw (SALOME::SALOME_Exception);
803     char*                   GetThreshold ( SMESH::ConnectedElements::ThresholdType& type );
804
805   private:
806     Controls::ConnectedElementsPtr          myConnectedElementsPtr;
807     std::string                             myVertexID;
808   };
809   
810   /*
811     Class       : Comparator_i
812     Description : Base class for comparators
813   */
814   class SMESH_I_EXPORT Comparator_i: public virtual POA_SMESH::Comparator,
815                                      public virtual Predicate_i
816   {
817   public:
818     virtual                         ~Comparator_i();
819     
820     virtual void                    SetMargin( CORBA::Double );
821     virtual void                    SetNumFunctor( NumericalFunctor_ptr );
822     
823     Controls::ComparatorPtr         GetComparator();
824     NumericalFunctor_i*             GetNumFunctor_i();
825     CORBA::Double                   GetMargin();
826     
827   protected:
828     Comparator_i();
829   protected:                                  
830     Controls::ComparatorPtr         myComparatorPtr;
831     NumericalFunctor_i*             myNumericalFunctor;
832   };
833   
834   
835   /*
836     Class       : LessThan_i
837     Description : Comparator "<"
838   */
839   class SMESH_I_EXPORT LessThan_i: public virtual POA_SMESH::LessThan,
840                                    public virtual Comparator_i
841   {
842   public:
843     LessThan_i();
844     FunctorType                     GetFunctorType();
845   };
846   
847   
848   /*
849     Class       : MoreThan_i
850     Description : Comparator ">"
851   */
852   class SMESH_I_EXPORT MoreThan_i: public virtual POA_SMESH::MoreThan,
853                                    public virtual Comparator_i
854   {
855   public:
856     MoreThan_i();
857     FunctorType                     GetFunctorType();
858   };
859   
860   
861   /*
862     Class       : EqualTo_i
863     Description : Comparator "="
864   */
865   class SMESH_I_EXPORT EqualTo_i: public virtual POA_SMESH::EqualTo,
866                                   public virtual Comparator_i
867   {
868   public:
869     EqualTo_i();
870     virtual void                    SetTolerance( CORBA::Double );
871     CORBA::Double                   GetTolerance();
872     FunctorType                     GetFunctorType();
873     
874   protected:
875     Controls::EqualToPtr            myEqualToPtr;
876   };
877   
878   
879   /*
880     Class       : LogicalNOT_i
881     Description : Logical NOT predicate
882   */
883   class SMESH_I_EXPORT LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
884                                      public virtual Predicate_i
885   {
886   public:
887     LogicalNOT_i();
888   virtual                         ~LogicalNOT_i();
889     
890     virtual void                    SetPredicate( Predicate_ptr );
891     Predicate_i*                    GetPredicate_i();
892     FunctorType                     GetFunctorType();
893     
894   protected:
895     Controls::LogicalNOTPtr         myLogicalNOTPtr;
896     Predicate_i*                    myPredicate;
897   };
898   
899   
900   /*
901     Class       : LogicalBinary_i
902     Description : Base class for binary logical predicate
903   */
904   class SMESH_I_EXPORT LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
905                                         public virtual Predicate_i
906   {
907   public:
908     virtual                         ~LogicalBinary_i();
909     virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
910     virtual void                    SetPredicate1( Predicate_ptr );
911     virtual void                    SetPredicate2( Predicate_ptr );
912     
913     Controls::LogicalBinaryPtr      GetLogicalBinary();
914     Predicate_i*                    GetPredicate1_i();
915     Predicate_i*                    GetPredicate2_i();
916     
917   protected:
918     LogicalBinary_i();
919   protected:  
920     Controls::LogicalBinaryPtr      myLogicalBinaryPtr;
921     Predicate_i*                    myPredicate1;
922     Predicate_i*                    myPredicate2;
923   };
924   
925   
926   /*
927     Class       : LogicalAND_i
928     Description : Logical AND
929   */
930   class SMESH_I_EXPORT LogicalAND_i: public virtual POA_SMESH::LogicalAND,
931                                      public virtual LogicalBinary_i
932   {
933   public:
934     LogicalAND_i();
935     FunctorType                     GetFunctorType();
936   };
937   
938   
939   /*
940     Class       : LogicalOR_i
941     Description : Logical OR
942   */
943   class SMESH_I_EXPORT LogicalOR_i: public virtual POA_SMESH::LogicalOR,
944                                     public virtual LogicalBinary_i
945   {
946   public:
947     LogicalOR_i();
948     FunctorType                     GetFunctorType();
949   };
950   
951   
952   /*
953     FILTER
954   */
955   class SMESH_I_EXPORT Filter_i: public virtual POA_SMESH::Filter,
956                                  public virtual SALOME::GenericObj_i,
957                                  public NotifyerAndWaiter
958   {
959   public:
960     Filter_i();
961     ~Filter_i();
962     
963     virtual
964     void
965     SetPredicate( Predicate_ptr );
966
967     virtual
968     void
969     SetMesh( SMESH_Mesh_ptr );
970
971     static
972     void
973     GetElementsId( Predicate_i*,
974                    const SMDS_Mesh*,
975                    Controls::Filter::TIdSequence& );
976     static
977     void           
978     GetElementsId( Predicate_i*,
979                    SMESH_Mesh_ptr,
980                    Controls::Filter::TIdSequence& );
981     
982     virtual
983     long_array*      
984     GetElementsId( SMESH_Mesh_ptr );
985
986     virtual
987     ElementType      
988     GetElementType();
989     
990     virtual
991     CORBA::Boolean   
992     GetCriteria( SMESH::Filter::Criteria_out theCriteria );
993
994     virtual
995     CORBA::Boolean
996     SetCriteria( const SMESH::Filter::Criteria& theCriteria );
997     
998     virtual
999     Predicate_ptr
1000     GetPredicate();
1001
1002     Predicate_i*     GetPredicate_i();
1003
1004     void FindBaseObjects();
1005     // finds groups it depends on
1006
1007     virtual void OnBaseObjModified(NotifyerAndWaiter* group, bool removed);
1008     // notified on change of myBaseGroups[i]
1009
1010     // =========================
1011     // SMESH_IDSource interface
1012     // =========================
1013     virtual SMESH::long_array*           GetIDs();
1014     virtual SMESH::long_array*           GetMeshInfo();
1015     virtual SMESH::long_array*           GetNbElementsByType();
1016     virtual SMESH::array_of_ElementType* GetTypes();
1017     virtual SMESH::SMESH_Mesh_ptr        GetMesh();
1018     virtual bool                         IsMeshInfoCorrect() { return true; }
1019     virtual SALOMEDS::TMPFile*           GetVtkUgStream();
1020
1021   private:
1022     Controls::Filter myFilter;
1023     Predicate_i*     myPredicate;
1024     SMESH_Mesh_var   myMesh;
1025
1026     std::vector< SMESH_GroupBase_i* > myBaseGroups;
1027   };
1028
1029
1030   /*
1031     FILTER LIBRARY
1032   */
1033   class SMESH_I_EXPORT FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
1034                                         public virtual SALOME::GenericObj_i
1035   {
1036   public:
1037     FilterLibrary_i( const char* theFileName );
1038     FilterLibrary_i();
1039     ~FilterLibrary_i();
1040     
1041     Filter_ptr              Copy( const char* theFilterName );
1042     
1043     CORBA::Boolean          Add     ( const char* theFilterName, Filter_ptr theFilter );
1044     CORBA::Boolean          AddEmpty( const char* theFilterName, ElementType theType );
1045     CORBA::Boolean          Delete  ( const char* theFilterName );
1046     CORBA::Boolean          Replace ( const char* theFilterName, 
1047                                       const char* theNewName, 
1048                                       Filter_ptr  theFilter );
1049     
1050     CORBA::Boolean          Save();
1051     CORBA::Boolean          SaveAs( const char* aFileName );
1052     
1053     CORBA::Boolean          IsPresent( const char* aFilterName );
1054     CORBA::Long             NbFilters( ElementType );
1055     string_array*           GetNames( ElementType );
1056     string_array*           GetAllNames();
1057     void                    SetFileName( const char* theFileName );
1058     char*                   GetFileName();
1059     
1060   private:
1061     char*                   myFileName;
1062     LDOM_Document           myDoc;
1063     FilterManager_var       myFilterMgr;
1064   };
1065   
1066   
1067   /*
1068     FILTER MANAGER
1069   */
1070   
1071   class SMESH_I_EXPORT FilterManager_i: public virtual POA_SMESH::FilterManager,
1072                                         public virtual SALOME::GenericObj_i
1073   {
1074   public:
1075     FilterManager_i();
1076     ~FilterManager_i();
1077
1078     MinimumAngle_ptr          CreateMinimumAngle();
1079     AspectRatio_ptr           CreateAspectRatio();
1080     AspectRatio3D_ptr         CreateAspectRatio3D();
1081     Warping_ptr               CreateWarping();
1082     Taper_ptr                 CreateTaper();
1083     Skew_ptr                  CreateSkew();
1084     Area_ptr                  CreateArea();
1085     Volume3D_ptr              CreateVolume3D();
1086     MaxElementLength2D_ptr    CreateMaxElementLength2D();
1087     MaxElementLength3D_ptr    CreateMaxElementLength3D();
1088     Length_ptr                CreateLength();
1089     Length2D_ptr              CreateLength2D();
1090     NodeConnectivityNumber_ptr CreateNodeConnectivityNumber();
1091     MultiConnection_ptr       CreateMultiConnection();
1092     MultiConnection2D_ptr     CreateMultiConnection2D();
1093     BallDiameter_ptr          CreateBallDiameter();
1094     
1095     BelongToMeshGroup_ptr     CreateBelongToMeshGroup();
1096     BelongToGeom_ptr          CreateBelongToGeom();
1097     BelongToPlane_ptr         CreateBelongToPlane();
1098     BelongToCylinder_ptr      CreateBelongToCylinder();
1099     BelongToGenSurface_ptr    CreateBelongToGenSurface();
1100     
1101     LyingOnGeom_ptr           CreateLyingOnGeom();
1102     
1103     FreeBorders_ptr           CreateFreeBorders();
1104     FreeEdges_ptr             CreateFreeEdges();
1105     FreeNodes_ptr             CreateFreeNodes();
1106     FreeFaces_ptr             CreateFreeFaces();
1107
1108     EqualNodes_ptr            CreateEqualNodes();
1109     EqualEdges_ptr            CreateEqualEdges();
1110     EqualFaces_ptr            CreateEqualFaces();
1111     EqualVolumes_ptr          CreateEqualVolumes();
1112
1113     RangeOfIds_ptr            CreateRangeOfIds();
1114     BadOrientedVolume_ptr     CreateBadOrientedVolume();
1115     BareBorderFace_ptr        CreateBareBorderFace();
1116     BareBorderVolume_ptr      CreateBareBorderVolume();
1117     OverConstrainedFace_ptr   CreateOverConstrainedFace();
1118     OverConstrainedVolume_ptr CreateOverConstrainedVolume();
1119     LinearOrQuadratic_ptr     CreateLinearOrQuadratic();
1120     GroupColor_ptr            CreateGroupColor();
1121     ElemGeomType_ptr          CreateElemGeomType();
1122     ElemEntityType_ptr        CreateElemEntityType();
1123     CoplanarFaces_ptr         CreateCoplanarFaces();
1124     ConnectedElements_ptr     CreateConnectedElements();
1125
1126     LessThan_ptr              CreateLessThan();
1127     MoreThan_ptr              CreateMoreThan();
1128     EqualTo_ptr               CreateEqualTo();
1129     
1130     LogicalNOT_ptr            CreateLogicalNOT();
1131     LogicalAND_ptr            CreateLogicalAND();
1132     LogicalOR_ptr             CreateLogicalOR();
1133     
1134     Filter_ptr                CreateFilter();
1135     
1136     FilterLibrary_ptr         LoadLibrary( const char* aFileName );
1137     FilterLibrary_ptr         CreateLibrary();
1138     CORBA::Boolean            DeleteLibrary( const char* aFileName );
1139   };
1140   
1141   
1142   Predicate_i* 
1143   GetPredicate( SMESH::Predicate_ptr thePredicate );
1144
1145   const char*        FunctorTypeToString(SMESH::FunctorType ft);
1146   SMESH::FunctorType StringToFunctorType(const char*       str);
1147 }
1148
1149
1150 #endif