src/SMESH_I/SMESH_Filter_i.hxx

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