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     void                            SetUseBoundaries( CORBA::Boolean theUseBndRestrictions );
 397     CORBA::Boolean                  GetUseBoundaries();
 398
 399   protected:
 400     Controls::ElementsOnSurfacePtr  myElementsOnSurfacePtr;
 401     char*                           myShapeName;
 402     char*                           myShapeID;
 403     Handle(Standard_Type)           mySurfaceType;
 404   };
 405
 406   /*
 407     Class       : BelongToPlane_i
 408     Description : Verify whether mesh element lie in pointed Geom planar object
 409   */
 410   class SMESH_I_EXPORT BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
 411                          public virtual BelongToSurface_i
 412   {
 413   public:
 414     BelongToPlane_i();
 415     void                            SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 416     FunctorType                     GetFunctorType();
 417   };
 418
 419   /*
 420     Class       : BelongToCylinder_i
 421     Description : Verify whether mesh element lie in pointed Geom cylindrical object
 422   */
 423   class SMESH_I_EXPORT BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
 424                             public virtual BelongToSurface_i
 425   {
 426   public:
 427     BelongToCylinder_i();
 428     void                            SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 429     FunctorType                     GetFunctorType();
 430   };
 431
 432   /*
 433     Class       : BelongToGenSurface_i
 434     Description : Verify whether mesh element lie on pointed Geom surfasic object
 435   */
 436   class BelongToGenSurface_i: public virtual POA_SMESH::BelongToGenSurface,
 437                               public virtual BelongToSurface_i
 438   {
 439   public:
 440     BelongToGenSurface_i();
 441     void                            SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
 442     FunctorType                     GetFunctorType();
 443   };
 444
 445   /*
 446     Class       : LyingOnGeom_i
 447     Description : Predicate for selection on geometrical support(lying or partially lying)
 448   */
 449   class SMESH_I_EXPORT LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
 450                        public virtual Predicate_i
 451   {
 452   public:
 453     LyingOnGeom_i();
 454     virtual                         ~LyingOnGeom_i();
 455
 456     void                            SetGeom( GEOM::GEOM_Object_ptr theGeom );
 457     void                            SetElementType( ElementType theType );
 458     FunctorType                     GetFunctorType();
 459
 460     void                            SetGeom( const TopoDS_Shape& theShape );
 461
 462     void                            SetShapeName( const char* theName );
 463     void                            SetShape( const char* theID, const char* theName );
 464     char*                           GetShapeName();
 465     char*                           GetShapeID();
 466
 467   protected:
 468     Controls::LyingOnGeomPtr        myLyingOnGeomPtr;
 469     char*                           myShapeName;
 470     char*                           myShapeID;
 471   };
 472
 473   /*
 474     Class       : FreeBorders_i
 475     Description : Predicate for free borders
 476   */
 477   class SMESH_I_EXPORT FreeBorders_i: public virtual POA_SMESH::FreeBorders,
 478                        public virtual Predicate_i
 479   {
 480   public:
 481     FreeBorders_i();
 482     FunctorType                     GetFunctorType();
 483   };
 484
 485
 486   /*
 487     Class       : FreeEdges_i
 488     Description : Predicate for free edges
 489   */
 490   class SMESH_I_EXPORT FreeEdges_i: public virtual POA_SMESH::FreeEdges,
 491                      public virtual Predicate_i
 492   {
 493   public:
 494     FreeEdges_i();
 495     SMESH::FreeEdges::Borders*      GetBorders();
 496     FunctorType                     GetFunctorType();
 497
 498   protected:
 499     Controls::FreeEdgesPtr          myFreeEdgesPtr;
 500   };
 501
 502
 503   /*
 504     Class       : RangeOfIds_i
 505     Description : Predicate for Range of Ids
 506   */
 507   class SMESH_I_EXPORT RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
 508                       public virtual Predicate_i
 509   {
 510   public:
 511     RangeOfIds_i();
 512     void                            SetRange( const SMESH::long_array& theIds );
 513     CORBA::Boolean                  SetRangeStr( const char* theRange );
 514     char*                           GetRangeStr();
 515
 516     void                            SetElementType( ElementType theType );
 517     FunctorType                     GetFunctorType();
 518
 519   protected:
 520     Controls::RangeOfIdsPtr         myRangeOfIdsPtr;
 521   };
 522
 523   /*
 524     Class       : Comparator_i
 525     Description : Base class for comparators
 526   */
 527   class SMESH_I_EXPORT Comparator_i: public virtual POA_SMESH::Comparator,
 528                       public virtual Predicate_i
 529   {
 530   public:
 531     virtual                         ~Comparator_i();
 532
 533     virtual void                    SetMargin( CORBA::Double );
 534     virtual void                    SetNumFunctor( NumericalFunctor_ptr );
 535
 536     Controls::ComparatorPtr         GetComparator();
 537     NumericalFunctor_i*             GetNumFunctor_i();
 538     CORBA::Double                   GetMargin();
 539
 540   protected:
 541     Comparator_i();
 542   protected:
 543     Controls::ComparatorPtr         myComparatorPtr;
 544     NumericalFunctor_i*             myNumericalFunctor;
 545   };
 546
 547
 548   /*
 549     Class       : LessThan_i
 550     Description : Comparator "<"
 551   */
 552   class SMESH_I_EXPORT LessThan_i: public virtual POA_SMESH::LessThan,
 553                     public virtual Comparator_i
 554   {
 555   public:
 556     LessThan_i();
 557     FunctorType                     GetFunctorType();
 558   };
 559
 560
 561   /*
 562     Class       : MoreThan_i
 563     Description : Comparator ">"
 564   */
 565   class SMESH_I_EXPORT MoreThan_i: public virtual POA_SMESH::MoreThan,
 566                     public virtual Comparator_i
 567   {
 568   public:
 569     MoreThan_i();
 570     FunctorType                     GetFunctorType();
 571   };
 572
 573
 574   /*
 575     Class       : EqualTo_i
 576     Description : Comparator "="
 577   */
 578   class SMESH_I_EXPORT EqualTo_i: public virtual POA_SMESH::EqualTo,
 579                    public virtual Comparator_i
 580   {
 581   public:
 582     EqualTo_i();
 583     virtual void                    SetTolerance( CORBA::Double );
 584     CORBA::Double                   GetTolerance();
 585     FunctorType                     GetFunctorType();
 586
 587   protected:
 588     Controls::EqualToPtr            myEqualToPtr;
 589   };
 590
 591
 592   /*
 593     Class       : LogicalNOT_i
 594     Description : Logical NOT predicate
 595   */
 596   class SMESH_I_EXPORT LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
 597                       public virtual Predicate_i
 598   {
 599   public:
 600     LogicalNOT_i();
 601   virtual                         ~LogicalNOT_i();
 602
 603     virtual void                    SetPredicate( Predicate_ptr );
 604     Predicate_i*                    GetPredicate_i();
 605     FunctorType                     GetFunctorType();
 606
 607   protected:
 608     Controls::LogicalNOTPtr         myLogicalNOTPtr;
 609     Predicate_i*                    myPredicate;
 610   };
 611
 612
 613   /*
 614     Class       : LogicalBinary_i
 615     Description : Base class for binary logical predicate
 616   */
 617   class SMESH_I_EXPORT LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
 618                          public virtual Predicate_i
 619   {
 620   public:
 621     virtual                         ~LogicalBinary_i();
 622     virtual void                    SetMesh( SMESH_Mesh_ptr theMesh );
 623     virtual void                    SetPredicate1( Predicate_ptr );
 624     virtual void                    SetPredicate2( Predicate_ptr );
 625
 626     Controls::LogicalBinaryPtr      GetLogicalBinary();
 627     Predicate_i*                    GetPredicate1_i();
 628     Predicate_i*                    GetPredicate2_i();
 629
 630   protected:
 631     LogicalBinary_i();
 632   protected:
 633     Controls::LogicalBinaryPtr      myLogicalBinaryPtr;
 634     Predicate_i*                    myPredicate1;
 635     Predicate_i*                    myPredicate2;
 636   };
 637
 638
 639   /*
 640     Class       : LogicalAND_i
 641     Description : Logical AND
 642   */
 643   class SMESH_I_EXPORT LogicalAND_i: public virtual POA_SMESH::LogicalAND,
 644                       public virtual LogicalBinary_i
 645   {
 646   public:
 647     LogicalAND_i();
 648     FunctorType                     GetFunctorType();
 649   };
 650
 651
 652   /*
 653     Class       : LogicalOR_i
 654     Description : Logical OR
 655   */
 656   class SMESH_I_EXPORT LogicalOR_i: public virtual POA_SMESH::LogicalOR,
 657                      public virtual LogicalBinary_i
 658   {
 659   public:
 660     LogicalOR_i();
 661     FunctorType                     GetFunctorType();
 662   };
 663
 664
 665   /*
 666     FILTER
 667   */
 668   class SMESH_I_EXPORT Filter_i: public virtual POA_SMESH::Filter,
 669                   public virtual SALOME::GenericObj_i
 670   {
 671   public:
 672     Filter_i();
 673     ~Filter_i();
 674
 675     virtual
 676     void
 677     SetPredicate( Predicate_ptr );
 678
 679     virtual
 680     void
 681     SetMesh( SMESH_Mesh_ptr );
 682
 683     virtual
 684     SMESH::long_array*
 685     GetIDs();
 686
 687     static
 688     void
 689     GetElementsId( Predicate_i*,
 690                    const SMDS_Mesh*,
 691                    Controls::Filter::TIdSequence& );
 692     static
 693     void
 694     GetElementsId( Predicate_i*,
 695                    SMESH_Mesh_ptr,
 696                    Controls::Filter::TIdSequence& );
 697
 698     virtual
 699     long_array*
 700     GetElementsId( SMESH_Mesh_ptr );
 701
 702     virtual
 703     ElementType
 704     GetElementType();
 705
 706     virtual
 707     CORBA::Boolean
 708     GetCriteria( SMESH::Filter::Criteria_out theCriteria );
 709
 710     virtual
 711     CORBA::Boolean
 712     SetCriteria( const SMESH::Filter::Criteria& theCriteria );
 713
 714     virtual
 715     Predicate_ptr
 716     GetPredicate();
 717
 718     Predicate_i*     GetPredicate_i();
 719
 720   private:
 721     Controls::Filter myFilter;
 722     Predicate_i*     myPredicate;
 723     SMESH_Mesh_var   myMesh;
 724   };
 725
 726
 727   /*
 728     FILTER LIBRARY
 729   */
 730   class SMESH_I_EXPORT FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
 731                          public virtual SALOME::GenericObj_i
 732   {
 733   public:
 734     FilterLibrary_i( const char* theFileName );
 735     FilterLibrary_i();
 736     ~FilterLibrary_i();
 737
 738     Filter_ptr              Copy( const char* theFilterName );
 739
 740     CORBA::Boolean          Add     ( const char* theFilterName, Filter_ptr theFilter );
 741     CORBA::Boolean          AddEmpty( const char* theFilterName, ElementType theType );
 742     CORBA::Boolean          Delete  ( const char* theFilterName );
 743     CORBA::Boolean          Replace ( const char* theFilterName,
 744                                       const char* theNewName,
 745                                       Filter_ptr  theFilter );
 746
 747     CORBA::Boolean          Save();
 748     CORBA::Boolean          SaveAs( const char* aFileName );
 749
 750     CORBA::Boolean          IsPresent( const char* aFilterName );
 751     CORBA::Long             NbFilters( ElementType );
 752     string_array*           GetNames( ElementType );
 753     string_array*           GetAllNames();
 754     void                    SetFileName( const char* theFileName );
 755     char*                   GetFileName();
 756
 757   private:
 758     char*                   myFileName;
 759     LDOM_Document           myDoc;
 760     FilterManager_var       myFilterMgr;
 761   };
 762
 763
 764   /*
 765     FILTER MANAGER
 766   */
 767
 768   class SMESH_I_EXPORT FilterManager_i: public virtual POA_SMESH::FilterManager,
 769                          public virtual SALOME::GenericObj_i
 770   {
 771   public:
 772     FilterManager_i();
 773     ~FilterManager_i();
 774
 775     MinimumAngle_ptr          CreateMinimumAngle();
 776     AspectRatio_ptr           CreateAspectRatio();
 777     AspectRatio3D_ptr         CreateAspectRatio3D();
 778     Warping_ptr               CreateWarping();
 779     Taper_ptr                 CreateTaper();
 780     Skew_ptr                  CreateSkew();
 781     Area_ptr                  CreateArea();
 782     Volume3D_ptr              CreateVolume3D();
 783     Length_ptr                CreateLength();
 784     Length2D_ptr              CreateLength2D();
 785     MultiConnection_ptr       CreateMultiConnection();
 786     MultiConnection2D_ptr     CreateMultiConnection2D();
 787
 788     BelongToGeom_ptr          CreateBelongToGeom();
 789     BelongToPlane_ptr         CreateBelongToPlane();
 790     BelongToCylinder_ptr      CreateBelongToCylinder();
 791     BelongToGenSurface_ptr    CreateBelongToGenSurface();
 792
 793     LyingOnGeom_ptr           CreateLyingOnGeom();
 794
 795     FreeBorders_ptr           CreateFreeBorders();
 796     FreeEdges_ptr             CreateFreeEdges();
 797
 798     RangeOfIds_ptr            CreateRangeOfIds();
 799
 800     BadOrientedVolume_ptr     CreateBadOrientedVolume();
 801
 802     LessThan_ptr              CreateLessThan();
 803     MoreThan_ptr              CreateMoreThan();
 804     EqualTo_ptr               CreateEqualTo();
 805
 806     LogicalNOT_ptr            CreateLogicalNOT();
 807     LogicalAND_ptr            CreateLogicalAND();
 808     LogicalOR_ptr             CreateLogicalOR();
 809
 810     Filter_ptr                CreateFilter();
 811
 812     FilterLibrary_ptr         LoadLibrary( const char* aFileName );
 813     FilterLibrary_ptr         CreateLibrary();
 814     CORBA::Boolean            DeleteLibrary( const char* aFileName );
 815   };
 816
 817
 818   Predicate_i*
 819   GetPredicate( SMESH::Predicate_ptr thePredicate );
 820 }
 821
 822
 823 #endif