src/SMESH_I/SMESH_Filter_i.hxx

   1 //  Copyright (C) 2007-2008  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.
  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 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
  23 //  File   : SMESH_Filter_i.hxx
  24 //  Author : Alexey Petrov, OCC
  25 //  Module : SMESH
  26 //
  27 #ifndef _SMESH_FILTER_I_HXX_
  28 #define _SMESH_FILTER_I_HXX_
  29
  30 #include "SMESH.hxx"
  31
  32 #include <SALOMEconfig.h>
  33 #include CORBA_SERVER_HEADER(SMESH_Filter)
  34
  35 #include <LDOM_Document.hxx>
  36 #include <TopoDS_Shape.hxx>
  37
  38 #include "SALOME_GenericObj_i.hh"
  39 #include "SMESH_ControlsDef.hxx"
  40
  41 class SMESHDS_Mesh;
  42
  43 namespace SMESH
  44 {
  45
  46   namespace Controls
  47   {
  48
  49     /*
  50       Class       : BelongToGeom
  51       Description : Predicate for verifying whether entiy belong to
  52       specified geometrical support
  53     */
  54     class SMESH_I_EXPORT BelongToGeom: public virtual Predicate
  55     {
  56     public:
  57       BelongToGeom();
  58
  59       virtual void                    SetMesh( const SMDS_Mesh* theMesh );
  60       virtual void                    SetGeom( const TopoDS_Shape& theShape );
  61
  62       virtual bool                    IsSatisfy( long theElementId );
  63
  64       virtual void                    SetType( SMDSAbs_ElementType theType );
  65       virtual                         SMDSAbs_ElementType GetType() const;
  66
  67       TopoDS_Shape                    GetShape();
  68       const SMESHDS_Mesh*             GetMeshDS() const;
  69
  70     private:
  71       TopoDS_Shape                    myShape;
  72       const SMESHDS_Mesh*             myMeshDS;
  73       SMDSAbs_ElementType             myType;
  74     };
  75     typedef boost::shared_ptr<BelongToGeom> BelongToGeomPtr;
  76
  77     /*
  78       Class       : LyingOnGeom
  79       Description : Predicate for verifying whether entiy lying or partially lying on
  80       specified geometrical support
  81     */
  82     class SMESH_I_EXPORT LyingOnGeom: public virtual Predicate
  83     {
  84     public:
  85       LyingOnGeom();
  86
  87       virtual void                    SetMesh( const SMDS_Mesh* theMesh );
  88       virtual void                    SetGeom( const TopoDS_Shape& theShape );
  89
  90       virtual bool                    IsSatisfy( long theElementId );
  91
  92       virtual void                    SetType( SMDSAbs_ElementType theType );
  93       virtual                         SMDSAbs_ElementType GetType() const;
  94
  95       TopoDS_Shape                    GetShape();
  96       const SMESHDS_Mesh*             GetMeshDS() const;
  97
  98       virtual bool                    Contains( const SMESHDS_Mesh*     theMeshDS,
  99                                                 const TopoDS_Shape&     theShape,
 100                                                 const SMDS_MeshElement* theElem,
 101                                                 TopAbs_ShapeEnum        theFindShapeEnum,
 102                                                 TopAbs_ShapeEnum        theAvoidShapeEnum = TopAbs_SHAPE );
 103     private:
 104       TopoDS_Shape                    myShape;
 105       const SMESHDS_Mesh*             myMeshDS;
 106       SMDSAbs_ElementType             myType;
 107     };
 108     typedef boost::shared_ptr<LyingOnGeom> LyingOnGeomPtr;
 109   }
 110
 111   /*
 112     FUNCTORS
 113   */
 114
 115   /*
 116     Class       : Functor_i
 117     Description : An abstact class for all functors
 118   */
 119   class SMESH_I_EXPORT Functor_i: public virtual POA_SMESH::Functor,
 120                    public virtual SALOME::GenericObj_i
 121   {
 122   public:
 123     void                            SetMesh( SMESH_Mesh_ptr theMesh );
 124     Controls::FunctorPtr            GetFunctor(){ return myFunctorPtr;}
 125     ElementType                     GetElementType();
 126
 127   protected:
 128     Functor_i();
 129     ~Functor_i();
 130   protected:
 131     Controls::FunctorPtr            myFunctorPtr;
 132   };
 133
 134   /*
 135     Class       : NumericalFunctor_i
 136     Description : Base class for numerical functors
 137   */
 138   class SMESH_I_EXPORT NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
 139                             public virtual Functor_i
 140   {
 141   public:
 142     CORBA::Double                   GetValue( CORBA::Long theElementId );
 143     void                            SetPrecision( CORBA::Long thePrecision );
 144     CORBA::Long                     GetPrecision();
 145     Controls::NumericalFunctorPtr   GetNumericalFunctor();
 146
 147   protected:
 148     Controls::NumericalFunctorPtr   myNumericalFunctorPtr;
 149   };
 150
 151
 152   /*
 153     Class       : SMESH_MinimumAngleFunct
 154     Description : Functor for calculation of minimum angle
 155   */
 156   class SMESH_I_EXPORT MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
 157                         public virtual NumericalFunctor_i
 158   {
 159   public:
 160     MinimumAngle_i();
 161     FunctorType                     GetFunctorType();
 162   };
 163
 164
 165   /*
 166     Class       : AspectRatio_i
 167     Description : Functor for calculating aspect ratio
 168   */
 169   class SMESH_I_EXPORT AspectRatio_i: public virtual POA_SMESH::AspectRatio,
 170                        public virtual NumericalFunctor_i
 171   {
 172   public:
 173     AspectRatio_i();
 174     FunctorType                     GetFunctorType();
 175   };
 176
 177
 178   /*
 179     Class       : AspectRatio3D_i
 180     Description : Functor for calculating aspect ratio for 3D
 181   */
 182   class SMESH_I_EXPORT AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
 183                          public virtual NumericalFunctor_i
 184   {
 185   public:
 186     AspectRatio3D_i();
 187     FunctorType                     GetFunctorType();
 188   };
 189
 190
 191   /*
 192     Class       : Warping_i
 193     Description : Functor for calculating warping
 194   */
 195   class SMESH_I_EXPORT Warping_i: public virtual POA_SMESH::Warping,
 196                    public virtual NumericalFunctor_i
 197   {
 198   public:
 199     Warping_i();
 200     FunctorType                     GetFunctorType();
 201   };
 202
 203
 204   /*
 205     Class       : Taper_i
 206     Description : Functor for calculating taper
 207   */
 208   class SMESH_I_EXPORT Taper_i: public virtual POA_SMESH::Taper,
 209                  public virtual NumericalFunctor_i
 210   {
 211   public:
 212     Taper_i();
 213     FunctorType                     GetFunctorType();
 214   };
 215
 216
 217   /*
 218     Class       : Skew_i
 219     Description : Functor for calculating skew in degrees
 220   */
 221   class SMESH_I_EXPORT Skew_i: public virtual POA_SMESH::Skew,
 222                 public virtual NumericalFunctor_i
 223   {
 224   public:
 225     Skew_i();
 226     FunctorType                     GetFunctorType();
 227   };
 228
 229
 230   /*
 231     Class       : Area_i
 232     Description : Functor for calculating area
 233   */
 234   class SMESH_I_EXPORT Area_i: public virtual POA_SMESH::Area,
 235                 public virtual NumericalFunctor_i
 236   {
 237   public:
 238     Area_i();
 239     FunctorType                     GetFunctorType();
 240   };
 241
 242
 243   /*
 244     Class       : Volume3D_i
 245     Description : Functor for calculating volume of 3D element
 246   */
 247   class SMESH_I_EXPORT Volume3D_i: public virtual POA_SMESH::Volume3D,
 248                     public virtual NumericalFunctor_i
 249   {
 250   public:
 251     Volume3D_i();
 252     FunctorType                     GetFunctorType();
 253   };
 254
 255
 256   /*
 257     Class       : Length_i
 258     Description : Functor for calculating length of edge
 259   */
 260   class SMESH_I_EXPORT Length_i: public virtual POA_SMESH::Length,
 261                   public virtual NumericalFunctor_i
 262   {
 263   public:
 264     Length_i();
 265     FunctorType                     GetFunctorType();
 266   };
 267
 268   /*
 269     Class       : Length2D_i
 270     Description : Functor for calculating length of edge
 271   */
 272   class SMESH_I_EXPORT Length2D_i: public virtual POA_SMESH::Length2D,
 273                     public virtual NumericalFunctor_i
 274   {
 275   public:
 276     Length2D_i();
 277     SMESH::Length2D::Values*        GetValues();
 278     FunctorType                     GetFunctorType();
 279
 280   protected:
 281     Controls::Length2DPtr          myLength2DPtr;
 282   };
 283
 284
 285   /*
 286     Class       : MultiConnection_i
 287     Description : Functor for calculating number of faces conneted to the edge
 288   */
 289   class SMESH_I_EXPORT MultiConnection_i: public virtual POA_SMESH::MultiConnection,
 290                            public virtual NumericalFunctor_i
 291   {
 292   public:
 293     MultiConnection_i();
 294     FunctorType                     GetFunctorType();
 295   };
 296
 297   /*
 298     Class       : MultiConnection2D_i
 299     Description : Functor for calculating number of faces conneted to the edge
 300   */
 301   class SMESH_I_EXPORT MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
 302                              public virtual NumericalFunctor_i
 303   {
 304   public:
 305     MultiConnection2D_i();
 306     SMESH::MultiConnection2D::Values*  GetValues();
 307     FunctorType                        GetFunctorType();
 308
 309   protected:
 310     Controls::MultiConnection2DPtr     myMulticonnection2DPtr;
 311   };
 312
 313
 314   /*
 315     PREDICATES
 316   */
 317   /*
 318     Class       : Predicate_i
 319     Description : Base class for all predicates
 320   */
 321   class SMESH_I_EXPORT Predicate_i: public virtual POA_SMESH::Predicate,
 322                      public virtual Functor_i
 323   {
 324   public:
 325     CORBA::Boolean                  IsSatisfy( CORBA::Long theElementId );
 326     Controls::PredicatePtr          GetPredicate();
 327
 328   protected:
 329     Controls::PredicatePtr          myPredicatePtr;
 330   };
 331
 332
 333   /*
 334     Class       : BadOrientedVolume_i
 335     Description : Verify whether a mesh volume is incorrectly oriented from
 336     the point of view of MED convention
 337   */
 338   class SMESH_I_EXPORT BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
 339                              public virtual Predicate_i
 340   {
 341   public:
 342     BadOrientedVolume_i();
 343     FunctorType                     GetFunctorType();
 344   };
 345
 346   /*
 347     Class       : BelongToGeom_i
 348     Description : Predicate for selection on geometrical support
 349   */
 350   class SMESH_I_EXPORT BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
 351                         public virtual Predicate_i
 352   {
 353   public:
 354     BelongToGeom_i();
 355     virtual                         ~BelongToGeom_i();
 356
 357     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 358     void                            SetElementType( ElementType theType );
 359     FunctorType                     GetFunctorType();
 360
 361     void                            SetGeom( const TopoDS_Shape& theShape );
 362
 363     void                            SetShapeName( const char* theName );
 364     void                            SetShape( const char* theID, const char* theName );
 365     char*                           GetShapeName();
 366     char*                           GetShapeID();
 367
 368   protected:
 369     Controls::BelongToGeomPtr       myBelongToGeomPtr;
 370     char*                           myShapeName;
 371     char*                           myShapeID;
 372   };
 373
 374   /*
 375     Class       : BelongToSurface_i
 376     Description : Verify whether mesh element lie in pointed Geom planar object
 377   */
 378   class SMESH_I_EXPORT BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
 379                            public virtual Predicate_i
 380   {
 381   public:
 382     BelongToSurface_i( const Handle(Standard_Type)& );
 383     virtual                         ~BelongToSurface_i();
 384
 385     void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 386
 387     void                            SetShapeName( const char* theName, ElementType theType );
 388     void                            SetShape( const char* theID, const char* theName, ElementType theType );
 389     char*                           GetShapeName();
 390     char*                           GetShapeID();
 391
 392     void                            SetTolerance( CORBA::Double );
 393     CORBA::Double                   GetTolerance();
 394
 395     void                            SetUseBoundaries( CORBA::Boolean theUseBndRestrictions );
 396     CORBA::Boolean                  GetUseBoundaries();
 397
 398   protected:
 399     Controls::ElementsOnSurfacePtr  myElementsOnSurfacePtr;
 400     char*                           myShapeName;
 401     char*                           myShapeID;
 402     Handle(Standard_Type)           mySurfaceType;
 403   };
 404
 405   /*
 406     Class       : BelongToPlane_i
 407     Description : Verify whether mesh element lie in pointed Geom planar object
 408   */
 409   class SMESH_I_EXPORT BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
 410                          public virtual BelongToSurface_i
 411   {
 412   public:
 413     BelongToPlane_i();
 414     void                            SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 415     FunctorType                     GetFunctorType();
 416   };
 417
 418   /*
 419     Class       : BelongToCylinder_i
 420     Description : Verify whether mesh element lie in pointed Geom cylindrical object
 421   */
 422   class SMESH_I_EXPORT BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
 423                             public virtual BelongToSurface_i
 424   {
 425   public:
 426     BelongToCylinder_i();
 427     void                            SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 428     FunctorType                     GetFunctorType();
 429   };
 430
 431   /*
 432     Class       : BelongToGenSurface_i
 433     Description : Verify whether mesh element lie on pointed Geom surfasic object
 434   */
 435   class BelongToGenSurface_i: public virtual POA_SMESH::BelongToGenSurface,
 436                               public virtual BelongToSurface_i
 437   {
 438   public:
 439     BelongToGenSurface_i();
 440     void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 441     FunctorType                     GetFunctorType();
 442   };
 443
 444   /*
 445     Class       : LyingOnGeom_i
 446     Description : Predicate for selection on geometrical support(lying or partially lying)
 447   */
 448   class SMESH_I_EXPORT LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
 449                        public virtual Predicate_i
 450   {
 451   public:
 452     LyingOnGeom_i();
 453     virtual                         ~LyingOnGeom_i();
 454
 455     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 456     void                            SetElementType( ElementType theType );
 457     FunctorType                     GetFunctorType();
 458
 459     void                            SetGeom( const TopoDS_Shape& theShape );
 460
 461     void                            SetShapeName( const char* theName );
 462     void                            SetShape( const char* theID, const char* theName );
 463     char*                           GetShapeName();
 464     char*                           GetShapeID();
 465
 466   protected:
 467     Controls::LyingOnGeomPtr        myLyingOnGeomPtr;
 468     char*                           myShapeName;
 469     char*                           myShapeID;
 470   };
 471
 472   /*
 473     Class       : FreeBorders_i
 474     Description : Predicate for free borders
 475   */
 476   class SMESH_I_EXPORT FreeBorders_i: public virtual POA_SMESH::FreeBorders,
 477                        public virtual Predicate_i
 478   {
 479   public:
 480     FreeBorders_i();
 481     FunctorType                     GetFunctorType();
 482   };
 483
 484
 485   /*
 486     Class       : FreeEdges_i
 487     Description : Predicate for free edges
 488   */
 489   class SMESH_I_EXPORT FreeEdges_i: public virtual POA_SMESH::FreeEdges,
 490                      public virtual Predicate_i
 491   {
 492   public:
 493     FreeEdges_i();
 494     SMESH::FreeEdges::Borders*      GetBorders();
 495     FunctorType                     GetFunctorType();
 496
 497   protected:
 498     Controls::FreeEdgesPtr          myFreeEdgesPtr;
 499   };
 500
 501
 502   /*
 503     Class       : RangeOfIds_i
 504     Description : Predicate for Range of Ids
 505   */
 506   class SMESH_I_EXPORT RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
 507                       public virtual Predicate_i
 508   {
 509   public:
 510     RangeOfIds_i();
 511     void                            SetRange( const SMESH::long_array& theIds );
 512     CORBA::Boolean                  SetRangeStr( const char* theRange );
 513     char*                           GetRangeStr();
 514
 515     void                            SetElementType( ElementType theType );
 516     FunctorType                     GetFunctorType();
 517
 518   protected:
 519     Controls::RangeOfIdsPtr         myRangeOfIdsPtr;
 520   };
 521
 522   /*
 523     Class       : Comparator_i
 524     Description : Base class for comparators
 525   */
 526   class SMESH_I_EXPORT Comparator_i: public virtual POA_SMESH::Comparator,
 527                       public virtual Predicate_i
 528   {
 529   public:
 530     virtual                         ~Comparator_i();
 531
 532     virtual void                    SetMargin( CORBA::Double );
 533     virtual void                    SetNumFunctor( NumericalFunctor_ptr );
 534
 535     Controls::ComparatorPtr         GetComparator();
 536     NumericalFunctor_i*             GetNumFunctor_i();
 537     CORBA::Double                   GetMargin();
 538
 539   protected:
 540     Comparator_i();
 541   protected:
 542     Controls::ComparatorPtr         myComparatorPtr;
 543     NumericalFunctor_i*             myNumericalFunctor;
 544   };
 545
 546
 547   /*
 548     Class       : LessThan_i
 549     Description : Comparator "<"
 550   */
 551   class SMESH_I_EXPORT LessThan_i: public virtual POA_SMESH::LessThan,
 552                     public virtual Comparator_i
 553   {
 554   public:
 555     LessThan_i();
 556     FunctorType                     GetFunctorType();
 557   };
 558
 559
 560   /*
 561     Class       : MoreThan_i
 562     Description : Comparator ">"
 563   */
 564   class SMESH_I_EXPORT MoreThan_i: public virtual POA_SMESH::MoreThan,
 565                     public virtual Comparator_i
 566   {
 567   public:
 568     MoreThan_i();
 569     FunctorType                     GetFunctorType();
 570   };
 571
 572
 573   /*
 574     Class       : EqualTo_i
 575     Description : Comparator "="
 576   */
 577   class SMESH_I_EXPORT EqualTo_i: public virtual POA_SMESH::EqualTo,
 578                    public virtual Comparator_i
 579   {
 580   public:
 581     EqualTo_i();
 582     virtual void                    SetTolerance( CORBA::Double );
 583     CORBA::Double                   GetTolerance();
 584     FunctorType                     GetFunctorType();
 585
 586   protected:
 587     Controls::EqualToPtr            myEqualToPtr;
 588   };
 589
 590
 591   /*
 592     Class       : LogicalNOT_i
 593     Description : Logical NOT predicate
 594   */
 595   class SMESH_I_EXPORT LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
 596                       public virtual Predicate_i
 597   {
 598   public:
 599     LogicalNOT_i();
 600   virtual                         ~LogicalNOT_i();
 601
 602     virtual void                    SetPredicate( Predicate_ptr );
 603     Predicate_i*                    GetPredicate_i();
 604     FunctorType                     GetFunctorType();
 605
 606   protected:
 607     Controls::LogicalNOTPtr         myLogicalNOTPtr;
 608     Predicate_i*                    myPredicate;
 609   };
 610
 611
 612   /*
 613     Class       : LogicalBinary_i
 614     Description : Base class for binary logical predicate
 615   */
 616   class SMESH_I_EXPORT LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
 617                          public virtual Predicate_i
 618   {
 619   public:
 620     virtual                         ~LogicalBinary_i();
 621     virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
 622     virtual void                    SetPredicate1( Predicate_ptr );
 623     virtual void                    SetPredicate2( Predicate_ptr );
 624
 625     Controls::LogicalBinaryPtr      GetLogicalBinary();
 626     Predicate_i*                    GetPredicate1_i();
 627     Predicate_i*                    GetPredicate2_i();
 628
 629   protected:
 630     LogicalBinary_i();
 631   protected:
 632     Controls::LogicalBinaryPtr      myLogicalBinaryPtr;
 633     Predicate_i*                    myPredicate1;
 634     Predicate_i*                    myPredicate2;
 635   };
 636
 637
 638   /*
 639     Class       : LogicalAND_i
 640     Description : Logical AND
 641   */
 642   class SMESH_I_EXPORT LogicalAND_i: public virtual POA_SMESH::LogicalAND,
 643                       public virtual LogicalBinary_i
 644   {
 645   public:
 646     LogicalAND_i();
 647     FunctorType                     GetFunctorType();
 648   };
 649
 650
 651   /*
 652     Class       : LogicalOR_i
 653     Description : Logical OR
 654   */
 655   class SMESH_I_EXPORT LogicalOR_i: public virtual POA_SMESH::LogicalOR,
 656                      public virtual LogicalBinary_i
 657   {
 658   public:
 659     LogicalOR_i();
 660     FunctorType                     GetFunctorType();
 661   };
 662
 663
 664   /*
 665     FILTER
 666   */
 667   class SMESH_I_EXPORT Filter_i: public virtual POA_SMESH::Filter,
 668                   public virtual SALOME::GenericObj_i
 669   {
 670   public:
 671     Filter_i();
 672     ~Filter_i();
 673
 674     virtual
 675     void
 676     SetPredicate( Predicate_ptr );
 677
 678     virtual
 679     void
 680     SetMesh( SMESH_Mesh_ptr );
 681
 682     virtual
 683     SMESH::long_array*
 684     GetIDs();
 685
 686     static
 687     void
 688     GetElementsId( Predicate_i*,
 689                    const SMDS_Mesh*,
 690                    Controls::Filter::TIdSequence& );
 691     static
 692     void
 693     GetElementsId( Predicate_i*,
 694                    SMESH_Mesh_ptr,
 695                    Controls::Filter::TIdSequence& );
 696
 697     virtual
 698     long_array*
 699     GetElementsId( SMESH_Mesh_ptr );
 700
 701     virtual
 702     ElementType
 703     GetElementType();
 704
 705     virtual
 706     CORBA::Boolean
 707     GetCriteria( SMESH::Filter::Criteria_out theCriteria );
 708
 709     virtual
 710     CORBA::Boolean
 711     SetCriteria( const SMESH::Filter::Criteria& theCriteria );
 712
 713     virtual
 714     Predicate_ptr
 715     GetPredicate();
 716
 717     Predicate_i*     GetPredicate_i();
 718
 719   private:
 720     Controls::Filter myFilter;
 721     Predicate_i*     myPredicate;
 722     SMESH_Mesh_var   myMesh;
 723   };
 724
 725
 726   /*
 727     FILTER LIBRARY
 728   */
 729   class SMESH_I_EXPORT FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
 730                          public virtual SALOME::GenericObj_i
 731   {
 732   public:
 733     FilterLibrary_i( const char* theFileName );
 734     FilterLibrary_i();
 735     ~FilterLibrary_i();
 736
 737     Filter_ptr              Copy( const char* theFilterName );
 738
 739     CORBA::Boolean          Add     ( const char* theFilterName, Filter_ptr theFilter );
 740     CORBA::Boolean          AddEmpty( const char* theFilterName, ElementType theType );
 741     CORBA::Boolean          Delete  ( const char* theFilterName );
 742     CORBA::Boolean          Replace ( const char* theFilterName,
 743                                       const char* theNewName,
 744                                       Filter_ptr  theFilter );
 745
 746     CORBA::Boolean          Save();
 747     CORBA::Boolean          SaveAs( const char* aFileName );
 748
 749     CORBA::Boolean          IsPresent( const char* aFilterName );
 750     CORBA::Long             NbFilters( ElementType );
 751     string_array*           GetNames( ElementType );
 752     string_array*           GetAllNames();
 753     void                    SetFileName( const char* theFileName );
 754     char*                   GetFileName();
 755
 756   private:
 757     char*                   myFileName;
 758     LDOM_Document           myDoc;
 759     FilterManager_var       myFilterMgr;
 760   };
 761
 762
 763   /*
 764     FILTER MANAGER
 765   */
 766
 767   class SMESH_I_EXPORT FilterManager_i: public virtual POA_SMESH::FilterManager,
 768                          public virtual SALOME::GenericObj_i
 769   {
 770   public:
 771     FilterManager_i();
 772     ~FilterManager_i();
 773
 774     MinimumAngle_ptr          CreateMinimumAngle();
 775     AspectRatio_ptr           CreateAspectRatio();
 776     AspectRatio3D_ptr         CreateAspectRatio3D();
 777     Warping_ptr               CreateWarping();
 778     Taper_ptr                 CreateTaper();
 779     Skew_ptr                  CreateSkew();
 780     Area_ptr                  CreateArea();
 781     Volume3D_ptr              CreateVolume3D();
 782     Length_ptr                CreateLength();
 783     Length2D_ptr              CreateLength2D();
 784     MultiConnection_ptr       CreateMultiConnection();
 785     MultiConnection2D_ptr     CreateMultiConnection2D();
 786
 787     BelongToGeom_ptr          CreateBelongToGeom();
 788     BelongToPlane_ptr         CreateBelongToPlane();
 789     BelongToCylinder_ptr      CreateBelongToCylinder();
 790     BelongToGenSurface_ptr    CreateBelongToGenSurface();
 791
 792     LyingOnGeom_ptr           CreateLyingOnGeom();
 793
 794     FreeBorders_ptr           CreateFreeBorders();
 795     FreeEdges_ptr             CreateFreeEdges();
 796
 797     RangeOfIds_ptr            CreateRangeOfIds();
 798
 799     BadOrientedVolume_ptr     CreateBadOrientedVolume();
 800
 801     LessThan_ptr              CreateLessThan();
 802     MoreThan_ptr              CreateMoreThan();
 803     EqualTo_ptr               CreateEqualTo();
 804
 805     LogicalNOT_ptr            CreateLogicalNOT();
 806     LogicalAND_ptr            CreateLogicalAND();
 807     LogicalOR_ptr             CreateLogicalOR();
 808
 809     Filter_ptr                CreateFilter();
 810
 811     FilterLibrary_ptr         LoadLibrary( const char* aFileName );
 812     FilterLibrary_ptr         CreateLibrary();
 813     CORBA::Boolean            DeleteLibrary( const char* aFileName );
 814   };
 815
 816
 817   Predicate_i*
 818   GetPredicate( SMESH::Predicate_ptr thePredicate );
 819 }
 820
 821
 822 #endif