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