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