-// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
// File : SMESH_Filter_i.hxx
// Author : Alexey Petrov, OCC
// Module : SMESH
-
+//
#ifndef _SMESH_FILTER_I_HXX_
#define _SMESH_FILTER_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Filter)
#include "SALOME_GenericObj_i.hh"
#include "SMESH_ControlsDef.hxx"
+#include <list>
+
class SMESHDS_Mesh;
namespace SMESH
{
+ // ================================================================================
namespace Controls
{
-
+
/*
Class : BelongToGeom
Description : Predicate for verifying whether entiy belong to
specified geometrical support
*/
- class BelongToGeom: public virtual Predicate
+ class SMESH_I_EXPORT BelongToGeom: public virtual Predicate
{
public:
BelongToGeom();
-
+
virtual void SetMesh( const SMDS_Mesh* theMesh );
virtual void SetGeom( const TopoDS_Shape& theShape );
-
+
virtual bool IsSatisfy( long theElementId );
-
+
virtual void SetType( SMDSAbs_ElementType theType );
virtual SMDSAbs_ElementType GetType() const;
-
+
TopoDS_Shape GetShape();
const SMESHDS_Mesh* GetMeshDS() const;
-
+
+ void SetTolerance( double );
+ double GetTolerance();
+
private:
+ virtual void init();
+
TopoDS_Shape myShape;
const SMESHDS_Mesh* myMeshDS;
SMDSAbs_ElementType myType;
+ bool myIsSubshape;
+ double myTolerance; // only if myIsSubshape == false
+ Controls::ElementsOnShapePtr myElementsOnShapePtr; // only if myIsSubshape == false
};
typedef boost::shared_ptr<BelongToGeom> BelongToGeomPtr;
-
+
/*
Class : LyingOnGeom
Description : Predicate for verifying whether entiy lying or partially lying on
specified geometrical support
*/
- class LyingOnGeom: public virtual Predicate
+ class SMESH_I_EXPORT LyingOnGeom: public virtual Predicate
{
public:
LyingOnGeom();
TopoDS_Shape GetShape();
const SMESHDS_Mesh* GetMeshDS() const;
+
+ void SetTolerance( double );
+ double GetTolerance();
virtual bool Contains( const SMESHDS_Mesh* theMeshDS,
- const TopoDS_Shape& theShape,
- const SMDS_MeshElement* theElem,
- TopAbs_ShapeEnum theFindShapeEnum,
- TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE );
+ const TopoDS_Shape& theShape,
+ const SMDS_MeshElement* theElem,
+ TopAbs_ShapeEnum theFindShapeEnum,
+ TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE );
private:
+ virtual void init();
+
TopoDS_Shape myShape;
const SMESHDS_Mesh* myMeshDS;
SMDSAbs_ElementType myType;
+ bool myIsSubshape;
+ double myTolerance; // only if myIsSubshape == false
+ Controls::ElementsOnShapePtr myElementsOnShapePtr; // only if myIsSubshape == false
};
typedef boost::shared_ptr<LyingOnGeom> LyingOnGeomPtr;
- }
-
+
+ } // namespace Controls
+
+ // ================================================================================
/*
FUNCTORS
*/
Class : Functor_i
Description : An abstact class for all functors
*/
- class Functor_i: public virtual POA_SMESH::Functor,
- public virtual SALOME::GenericObj_i
+ class SMESH_I_EXPORT Functor_i: public virtual POA_SMESH::Functor,
+ public virtual SALOME::GenericObj_i
{
public:
void SetMesh( SMESH_Mesh_ptr theMesh );
Class : NumericalFunctor_i
Description : Base class for numerical functors
*/
- class NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
- public virtual Functor_i
+ class SMESH_I_EXPORT NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
+ public virtual Functor_i
{
public:
CORBA::Double GetValue( CORBA::Long theElementId );
+ SMESH::Histogram* GetHistogram(CORBA::Short nbIntervals);
void SetPrecision( CORBA::Long thePrecision );
CORBA::Long GetPrecision();
Controls::NumericalFunctorPtr GetNumericalFunctor();
Class : SMESH_MinimumAngleFunct
Description : Functor for calculation of minimum angle
*/
- class MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
+ public virtual NumericalFunctor_i
{
public:
MinimumAngle_i();
Class : AspectRatio_i
Description : Functor for calculating aspect ratio
*/
- class AspectRatio_i: public virtual POA_SMESH::AspectRatio,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT AspectRatio_i: public virtual POA_SMESH::AspectRatio,
+ public virtual NumericalFunctor_i
{
public:
AspectRatio_i();
Class : AspectRatio3D_i
Description : Functor for calculating aspect ratio for 3D
*/
- class AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
+ public virtual NumericalFunctor_i
{
public:
AspectRatio3D_i();
Class : Warping_i
Description : Functor for calculating warping
*/
- class Warping_i: public virtual POA_SMESH::Warping,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT Warping_i: public virtual POA_SMESH::Warping,
+ public virtual NumericalFunctor_i
{
public:
Warping_i();
Class : Taper_i
Description : Functor for calculating taper
*/
- class Taper_i: public virtual POA_SMESH::Taper,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT Taper_i: public virtual POA_SMESH::Taper,
+ public virtual NumericalFunctor_i
{
public:
Taper_i();
Class : Skew_i
Description : Functor for calculating skew in degrees
*/
- class Skew_i: public virtual POA_SMESH::Skew,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT Skew_i: public virtual POA_SMESH::Skew,
+ public virtual NumericalFunctor_i
{
public:
Skew_i();
Class : Area_i
Description : Functor for calculating area
*/
- class Area_i: public virtual POA_SMESH::Area,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT Area_i: public virtual POA_SMESH::Area,
+ public virtual NumericalFunctor_i
{
public:
Area_i();
Class : Volume3D_i
Description : Functor for calculating volume of 3D element
*/
- class Volume3D_i: public virtual POA_SMESH::Volume3D,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT Volume3D_i: public virtual POA_SMESH::Volume3D,
+ public virtual NumericalFunctor_i
{
public:
Volume3D_i();
};
+ /*
+ Class : MaxElementLength2D_i
+ Description : Functor for calculating maximum length of 2D element
+ */
+ class SMESH_I_EXPORT MaxElementLength2D_i: public virtual POA_SMESH::MaxElementLength2D,
+ public virtual NumericalFunctor_i
+ {
+ public:
+ MaxElementLength2D_i();
+ FunctorType GetFunctorType();
+ };
+
+
+ /*
+ Class : MaxElementLength3D_i
+ Description : Functor for calculating maximum length of 3D element
+ */
+ class SMESH_I_EXPORT MaxElementLength3D_i: public virtual POA_SMESH::MaxElementLength3D,
+ public virtual NumericalFunctor_i
+ {
+ public:
+ MaxElementLength3D_i();
+ FunctorType GetFunctorType();
+ };
+
+
/*
Class : Length_i
Description : Functor for calculating length of edge
*/
- class Length_i: public virtual POA_SMESH::Length,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT Length_i: public virtual POA_SMESH::Length,
+ public virtual NumericalFunctor_i
{
public:
Length_i();
Class : Length2D_i
Description : Functor for calculating length of edge
*/
- class Length2D_i: public virtual POA_SMESH::Length2D,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT Length2D_i: public virtual POA_SMESH::Length2D,
+ public virtual NumericalFunctor_i
{
public:
Length2D_i();
Class : MultiConnection_i
Description : Functor for calculating number of faces conneted to the edge
*/
- class MultiConnection_i: public virtual POA_SMESH::MultiConnection,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT MultiConnection_i: public virtual POA_SMESH::MultiConnection,
+ public virtual NumericalFunctor_i
{
public:
MultiConnection_i();
Class : MultiConnection2D_i
Description : Functor for calculating number of faces conneted to the edge
*/
- class MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
- public virtual NumericalFunctor_i
+ class SMESH_I_EXPORT MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
+ public virtual NumericalFunctor_i
{
public:
MultiConnection2D_i();
Controls::MultiConnection2DPtr myMulticonnection2DPtr;
};
+ /*
+ Class : BallDiameter_i
+ Description : Functor returning diameter of a ball element
+ */
+ class SMESH_I_EXPORT BallDiameter_i: public virtual POA_SMESH::BallDiameter,
+ public virtual NumericalFunctor_i
+ {
+ public:
+ BallDiameter_i();
+ FunctorType GetFunctorType();
+ };
+
/*
PREDICATES
Class : Predicate_i
Description : Base class for all predicates
*/
- class Predicate_i: public virtual POA_SMESH::Predicate,
- public virtual Functor_i
+ class SMESH_I_EXPORT Predicate_i: public virtual POA_SMESH::Predicate,
+ public virtual Functor_i
{
public:
CORBA::Boolean IsSatisfy( CORBA::Long theElementId );
Description : Verify whether a mesh volume is incorrectly oriented from
the point of view of MED convention
*/
- class BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
- public virtual Predicate_i
+ class SMESH_I_EXPORT BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
+ public virtual Predicate_i
{
public:
BadOrientedVolume_i();
FunctorType GetFunctorType();
};
+ /*
+ Class : BareBorderVolume_i
+ Description : Verify whether a mesh volume has a free facet without a face on it
+ */
+ class SMESH_I_EXPORT BareBorderVolume_i: public virtual POA_SMESH::BareBorderVolume,
+ public virtual Predicate_i
+ {
+ public:
+ BareBorderVolume_i();
+ FunctorType GetFunctorType();
+ };
+
+ /*
+ Class : BareBorderFace_i
+ Description : Verify whether a mesh face has a free border without an edge on it
+ */
+ class SMESH_I_EXPORT BareBorderFace_i: public virtual POA_SMESH::BareBorderFace,
+ public virtual Predicate_i
+ {
+ public:
+ BareBorderFace_i();
+ FunctorType GetFunctorType();
+ };
+
+ /*
+ Class : OverConstrainedVolume_i
+ Description : Verify whether a mesh volume has only one facet shared with other volumes
+ */
+ class SMESH_I_EXPORT OverConstrainedVolume_i: public virtual POA_SMESH::OverConstrainedVolume,
+ public virtual Predicate_i
+ {
+ public:
+ OverConstrainedVolume_i();
+ FunctorType GetFunctorType();
+ };
+
+ /*
+ Class : OverConstrainedFace_i
+ Description : Verify whether a mesh face has only one border shared with other faces
+ */
+ class SMESH_I_EXPORT OverConstrainedFace_i: public virtual POA_SMESH::OverConstrainedFace,
+ public virtual Predicate_i
+ {
+ public:
+ OverConstrainedFace_i();
+ FunctorType GetFunctorType();
+ };
+
/*
Class : BelongToGeom_i
Description : Predicate for selection on geometrical support
*/
- class BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
- public virtual Predicate_i
+ class SMESH_I_EXPORT BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
+ public virtual Predicate_i
{
public:
BelongToGeom_i();
void SetGeom( const TopoDS_Shape& theShape );
void SetShapeName( const char* theName );
+ void SetShape( const char* theID, const char* theName );
char* GetShapeName();
+ char* GetShapeID();
+
+ void SetTolerance( CORBA::Double );
+ CORBA::Double GetTolerance();
protected:
Controls::BelongToGeomPtr myBelongToGeomPtr;
char* myShapeName;
+ char* myShapeID;
};
/*
Class : BelongToSurface_i
Description : Verify whether mesh element lie in pointed Geom planar object
*/
- class BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
- public virtual Predicate_i
+ class SMESH_I_EXPORT BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
+ public virtual Predicate_i
{
public:
BelongToSurface_i( const Handle(Standard_Type)& );
void SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
void SetShapeName( const char* theName, ElementType theType );
+ void SetShape( const char* theID, const char* theName, ElementType theType );
char* GetShapeName();
-
+ char* GetShapeID();
+
void SetTolerance( CORBA::Double );
CORBA::Double GetTolerance();
+ void SetUseBoundaries( CORBA::Boolean theUseBndRestrictions );
+ CORBA::Boolean GetUseBoundaries();
+
protected:
Controls::ElementsOnSurfacePtr myElementsOnSurfacePtr;
char* myShapeName;
+ char* myShapeID;
Handle(Standard_Type) mySurfaceType;
};
Class : BelongToPlane_i
Description : Verify whether mesh element lie in pointed Geom planar object
*/
- class BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
- public virtual BelongToSurface_i
+ class SMESH_I_EXPORT BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
+ public virtual BelongToSurface_i
{
public:
BelongToPlane_i();
Class : BelongToCylinder_i
Description : Verify whether mesh element lie in pointed Geom cylindrical object
*/
- class BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
- public virtual BelongToSurface_i
+ class SMESH_I_EXPORT BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
+ public virtual BelongToSurface_i
{
public:
BelongToCylinder_i();
void SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
FunctorType GetFunctorType();
};
+
+ /*
+ Class : BelongToGenSurface_i
+ Description : Verify whether mesh element lie on pointed Geom surfasic object
+ */
+ class BelongToGenSurface_i: public virtual POA_SMESH::BelongToGenSurface,
+ public virtual BelongToSurface_i
+ {
+ public:
+ BelongToGenSurface_i();
+ void SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType );
+ FunctorType GetFunctorType();
+ };
/*
Class : LyingOnGeom_i
Description : Predicate for selection on geometrical support(lying or partially lying)
*/
- class LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
- public virtual Predicate_i
+ class SMESH_I_EXPORT LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
+ public virtual Predicate_i
{
public:
LyingOnGeom_i();
void SetGeom( const TopoDS_Shape& theShape );
void SetShapeName( const char* theName );
+ void SetShape( const char* theID, const char* theName );
char* GetShapeName();
+ char* GetShapeID();
+
+ void SetTolerance( CORBA::Double );
+ CORBA::Double GetTolerance();
protected:
Controls::LyingOnGeomPtr myLyingOnGeomPtr;
char* myShapeName;
+ char* myShapeID;
};
/*
Class : FreeBorders_i
Description : Predicate for free borders
*/
- class FreeBorders_i: public virtual POA_SMESH::FreeBorders,
- public virtual Predicate_i
+ class SMESH_I_EXPORT FreeBorders_i: public virtual POA_SMESH::FreeBorders,
+ public virtual Predicate_i
{
public:
FreeBorders_i();
Class : FreeEdges_i
Description : Predicate for free edges
*/
- class FreeEdges_i: public virtual POA_SMESH::FreeEdges,
- public virtual Predicate_i
+ class SMESH_I_EXPORT FreeEdges_i: public virtual POA_SMESH::FreeEdges,
+ public virtual Predicate_i
{
public:
FreeEdges_i();
Controls::FreeEdgesPtr myFreeEdgesPtr;
};
+
+ /*
+ Class : FreeFaces_i
+ Description : Predicate for free faces
+ */
+ class SMESH_I_EXPORT FreeFaces_i: public virtual POA_SMESH::FreeFaces,
+ public virtual Predicate_i
+ {
+ public:
+ FreeFaces_i();
+ FunctorType GetFunctorType();
+ };
+
+
+ /*
+ Class : FreeNodes_i
+ Description : Predicate for free nodes
+ */
+ class SMESH_I_EXPORT FreeNodes_i: public virtual POA_SMESH::FreeNodes,
+ public virtual Predicate_i
+ {
+ public:
+ FreeNodes_i();
+ FunctorType GetFunctorType();
+ };
+
+
+ /*
+ Class : EqualNodes_i
+ Description : Predicate for equal nodes
+ */
+ class SMESH_I_EXPORT EqualNodes_i: public virtual POA_SMESH::EqualNodes,
+ public virtual Predicate_i
+ {
+ public:
+ EqualNodes_i();
+ FunctorType GetFunctorType();
+ void SetTolerance( double );
+ double GetTolerance();
+
+ private:
+ Controls::CoincidentNodesPtr myCoincidentNodesPtr;
+ };
+ /*
+ Class : EqualEdges_i
+ Description : Predicate for equal edges
+ */
+ class SMESH_I_EXPORT EqualEdges_i: public virtual POA_SMESH::EqualEdges,
+ public virtual Predicate_i
+ {
+ public:
+ EqualEdges_i();
+ FunctorType GetFunctorType();
+ };
+ /*
+ Class : EqualFaces_i
+ Description : Predicate for equal Faces
+ */
+ class SMESH_I_EXPORT EqualFaces_i: public virtual POA_SMESH::EqualFaces,
+ public virtual Predicate_i
+ {
+ public:
+ EqualFaces_i();
+ FunctorType GetFunctorType();
+ };
+ /*
+ Class : EqualVolumes_i
+ Description : Predicate for equal Volumes
+ */
+ class SMESH_I_EXPORT EqualVolumes_i: public virtual POA_SMESH::EqualVolumes,
+ public virtual Predicate_i
+ {
+ public:
+ EqualVolumes_i();
+ FunctorType GetFunctorType();
+ };
+
/*
Class : RangeOfIds_i
Description : Predicate for Range of Ids
*/
- class RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
- public virtual Predicate_i
+ class SMESH_I_EXPORT RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
+ public virtual Predicate_i
{
public:
RangeOfIds_i();
protected:
Controls::RangeOfIdsPtr myRangeOfIdsPtr;
};
+
+ /*
+ Class : LinearOrQuadratic_i
+ Description : Verify whether a mesh element is linear
+ */
+ class SMESH_I_EXPORT LinearOrQuadratic_i: public virtual POA_SMESH::LinearOrQuadratic,
+ public virtual Predicate_i
+ {
+ public:
+ LinearOrQuadratic_i();
+ FunctorType GetFunctorType();
+ void SetElementType( ElementType theType );
+
+ private:
+ Controls::LinearOrQuadraticPtr myLinearOrQuadraticPtr;
+ };
+
+ /*
+ Class : GroupColor_i
+ Description : Functor for check color of group to whic mesh element belongs to
+ */
+ class SMESH_I_EXPORT GroupColor_i: public virtual POA_SMESH::GroupColor,
+ public virtual Predicate_i
+ {
+ public:
+ GroupColor_i();
+ FunctorType GetFunctorType();
+
+ void SetElementType( ElementType theType );
+ void SetColorStr( const char* theColor );
+ char* GetColorStr();
+
+ private:
+ Controls::GroupColorPtr myGroupColorPtr;
+ };
+
+ /*
+ Class : ElemGeomType_i
+ Description : Functor for check element geometry type
+ */
+ class SMESH_I_EXPORT ElemGeomType_i: public virtual POA_SMESH::ElemGeomType,
+ public virtual Predicate_i
+ {
+ public:
+ ElemGeomType_i();
+ FunctorType GetFunctorType();
+
+ void SetElementType ( ElementType theType );
+ void SetGeometryType( GeometryType theType );
+ GeometryType GetGeometryType() const;
+
+ private:
+ Controls::ElemGeomTypePtr myElemGeomTypePtr;
+ };
+
+ /*
+ Class : CoplanarFaces_i
+ Description : Returns true if a mesh face is a coplanar neighbour to a given one
+ */
+ class SMESH_I_EXPORT CoplanarFaces_i: public virtual POA_SMESH::CoplanarFaces,
+ public virtual Predicate_i
+ {
+ public:
+ CoplanarFaces_i();
+ FunctorType GetFunctorType();
+
+ void SetFace ( CORBA::Long theFaceID );
+ void SetTolerance( CORBA::Double theToler );
+ char* GetFaceAsString () const;
+ CORBA::Long GetFace () const;
+ CORBA::Double GetTolerance () const;
+ private:
+ Controls::CoplanarFacesPtr myCoplanarFacesPtr;
+ };
/*
Class : Comparator_i
Description : Base class for comparators
*/
- class Comparator_i: public virtual POA_SMESH::Comparator,
- public virtual Predicate_i
+ class SMESH_I_EXPORT Comparator_i: public virtual POA_SMESH::Comparator,
+ public virtual Predicate_i
{
public:
virtual ~Comparator_i();
Class : LessThan_i
Description : Comparator "<"
*/
- class LessThan_i: public virtual POA_SMESH::LessThan,
- public virtual Comparator_i
+ class SMESH_I_EXPORT LessThan_i: public virtual POA_SMESH::LessThan,
+ public virtual Comparator_i
{
public:
LessThan_i();
Class : MoreThan_i
Description : Comparator ">"
*/
- class MoreThan_i: public virtual POA_SMESH::MoreThan,
- public virtual Comparator_i
+ class SMESH_I_EXPORT MoreThan_i: public virtual POA_SMESH::MoreThan,
+ public virtual Comparator_i
{
public:
MoreThan_i();
Class : EqualTo_i
Description : Comparator "="
*/
- class EqualTo_i: public virtual POA_SMESH::EqualTo,
- public virtual Comparator_i
+ class SMESH_I_EXPORT EqualTo_i: public virtual POA_SMESH::EqualTo,
+ public virtual Comparator_i
{
public:
EqualTo_i();
Class : LogicalNOT_i
Description : Logical NOT predicate
*/
- class LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
- public virtual Predicate_i
+ class SMESH_I_EXPORT LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
+ public virtual Predicate_i
{
public:
LogicalNOT_i();
Class : LogicalBinary_i
Description : Base class for binary logical predicate
*/
- class LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
- public virtual Predicate_i
+ class SMESH_I_EXPORT LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
+ public virtual Predicate_i
{
public:
virtual ~LogicalBinary_i();
Class : LogicalAND_i
Description : Logical AND
*/
- class LogicalAND_i: public virtual POA_SMESH::LogicalAND,
- public virtual LogicalBinary_i
+ class SMESH_I_EXPORT LogicalAND_i: public virtual POA_SMESH::LogicalAND,
+ public virtual LogicalBinary_i
{
public:
LogicalAND_i();
Class : LogicalOR_i
Description : Logical OR
*/
- class LogicalOR_i: public virtual POA_SMESH::LogicalOR,
- public virtual LogicalBinary_i
+ class SMESH_I_EXPORT LogicalOR_i: public virtual POA_SMESH::LogicalOR,
+ public virtual LogicalBinary_i
{
public:
LogicalOR_i();
/*
FILTER
*/
- class Filter_i: public virtual POA_SMESH::Filter,
- public virtual SALOME::GenericObj_i
+ class SMESH_I_EXPORT Filter_i: public virtual POA_SMESH::Filter,
+ public virtual SALOME::GenericObj_i
{
public:
Filter_i();
void
SetMesh( SMESH_Mesh_ptr );
- virtual
- SMESH::long_array*
- GetIDs();
-
static
void
GetElementsId( Predicate_i*,
- const SMDS_Mesh*,
- Controls::Filter::TIdSequence& );
+ const SMDS_Mesh*,
+ Controls::Filter::TIdSequence& );
static
void
GetElementsId( Predicate_i*,
- SMESH_Mesh_ptr,
- Controls::Filter::TIdSequence& );
+ SMESH_Mesh_ptr,
+ Controls::Filter::TIdSequence& );
virtual
long_array*
Predicate_i* GetPredicate_i();
+ // =========================
+ // SMESH_IDSource interface
+ // =========================
+ virtual SMESH::long_array* GetIDs();
+ virtual SMESH::long_array* GetMeshInfo();
+ virtual SMESH::array_of_ElementType* GetTypes();
+ virtual SMESH::SMESH_Mesh_ptr GetMesh();
+ virtual bool IsMeshInfoCorrect() { return true; }
+
+ /*!
+ * \brief Object notified on change of predicate
+ */
+ struct TPredicateChangeWaiter
+ {
+ virtual void PredicateChanged() = 0;
+ };
+ void AddWaiter( TPredicateChangeWaiter* waiter );
+ void RemoveWaiter( TPredicateChangeWaiter* waiter );
+
private:
Controls::Filter myFilter;
Predicate_i* myPredicate;
SMESH_Mesh_var myMesh;
+
+ std::list<TPredicateChangeWaiter*> myWaiters;
};
/*
FILTER LIBRARY
*/
- class FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
- public virtual SALOME::GenericObj_i
+ class SMESH_I_EXPORT FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
+ public virtual SALOME::GenericObj_i
{
public:
FilterLibrary_i( const char* theFileName );
CORBA::Boolean AddEmpty( const char* theFilterName, ElementType theType );
CORBA::Boolean Delete ( const char* theFilterName );
CORBA::Boolean Replace ( const char* theFilterName,
- const char* theNewName,
- Filter_ptr theFilter );
+ const char* theNewName,
+ Filter_ptr theFilter );
CORBA::Boolean Save();
CORBA::Boolean SaveAs( const char* aFileName );
FILTER MANAGER
*/
- class FilterManager_i: public virtual POA_SMESH::FilterManager,
- public virtual SALOME::GenericObj_i
+ class SMESH_I_EXPORT FilterManager_i: public virtual POA_SMESH::FilterManager,
+ public virtual SALOME::GenericObj_i
{
public:
FilterManager_i();
Skew_ptr CreateSkew();
Area_ptr CreateArea();
Volume3D_ptr CreateVolume3D();
+ MaxElementLength2D_ptr CreateMaxElementLength2D();
+ MaxElementLength3D_ptr CreateMaxElementLength3D();
Length_ptr CreateLength();
Length2D_ptr CreateLength2D();
MultiConnection_ptr CreateMultiConnection();
MultiConnection2D_ptr CreateMultiConnection2D();
+ BallDiameter_ptr CreateBallDiameter();
BelongToGeom_ptr CreateBelongToGeom();
BelongToPlane_ptr CreateBelongToPlane();
BelongToCylinder_ptr CreateBelongToCylinder();
+ BelongToGenSurface_ptr CreateBelongToGenSurface();
LyingOnGeom_ptr CreateLyingOnGeom();
FreeBorders_ptr CreateFreeBorders();
FreeEdges_ptr CreateFreeEdges();
-
+ FreeNodes_ptr CreateFreeNodes();
+ FreeFaces_ptr CreateFreeFaces();
+
+ EqualNodes_ptr CreateEqualNodes();
+ EqualEdges_ptr CreateEqualEdges();
+ EqualFaces_ptr CreateEqualFaces();
+ EqualVolumes_ptr CreateEqualVolumes();
+
RangeOfIds_ptr CreateRangeOfIds();
-
BadOrientedVolume_ptr CreateBadOrientedVolume();
-
+ BareBorderFace_ptr CreateBareBorderFace();
+ BareBorderVolume_ptr CreateBareBorderVolume();
+ OverConstrainedFace_ptr CreateOverConstrainedFace();
+ OverConstrainedVolume_ptr CreateOverConstrainedVolume();
+ LinearOrQuadratic_ptr CreateLinearOrQuadratic();
+ GroupColor_ptr CreateGroupColor();
+ ElemGeomType_ptr CreateElemGeomType();
+ CoplanarFaces_ptr CreateCoplanarFaces();
+
LessThan_ptr CreateLessThan();
MoreThan_ptr CreateMoreThan();
EqualTo_ptr CreateEqualTo();
Predicate_i*
GetPredicate( SMESH::Predicate_ptr thePredicate );
+
+ const char* FunctorTypeToString(SMESH::FunctorType ft);
+ SMESH::FunctorType StringToFunctorType(const char* str);
}