src/SMESH_I/SMESH_Filter_i.hxx

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