+/*
+ Class : LinearOrQuadratic_i
+ Description : Predicate to verify whether a mesh element is linear
+*/
+LinearOrQuadratic_i::LinearOrQuadratic_i()
+{
+ myLinearOrQuadraticPtr.reset(new Controls::LinearOrQuadratic());
+ myFunctorPtr = myPredicatePtr = myLinearOrQuadraticPtr;
+}
+
+void LinearOrQuadratic_i::SetElementType(ElementType theType)
+{
+ myLinearOrQuadraticPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+FunctorType LinearOrQuadratic_i::GetFunctorType()
+{
+ return SMESH::FT_LinearOrQuadratic;
+}
+
+/*
+ Class : GroupColor_i
+ Description : Functor for check color of group to whic mesh element belongs to
+*/
+GroupColor_i::GroupColor_i()
+{
+ myGroupColorPtr.reset(new Controls::GroupColor());
+ myFunctorPtr = myPredicatePtr = myGroupColorPtr;
+}
+
+FunctorType GroupColor_i::GetFunctorType()
+{
+ return SMESH::FT_GroupColor;
+}
+
+void GroupColor_i::SetColorStr( const char* theColor )
+{
+ myGroupColorPtr->SetColorStr(
+ TCollection_AsciiString( (Standard_CString)theColor ) );
+ TPythonDump()<<this<<".SetColorStr('"<<theColor<<"')";
+}
+
+char* GroupColor_i::GetColorStr()
+{
+ TCollection_AsciiString aStr;
+ myGroupColorPtr->GetColorStr( aStr );
+ return CORBA::string_dup( aStr.ToCString() );
+}
+
+void GroupColor_i::SetElementType(ElementType theType)
+{
+ myGroupColorPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+/*
+ Class : ElemGeomType_i
+ Description : Predicate check is element has indicated geometry type
+*/
+ElemGeomType_i::ElemGeomType_i()
+{
+ myElemGeomTypePtr.reset(new Controls::ElemGeomType());
+ myFunctorPtr = myPredicatePtr = myElemGeomTypePtr;
+}
+
+void ElemGeomType_i::SetElementType(ElementType theType)
+{
+ myElemGeomTypePtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+void ElemGeomType_i::SetGeometryType(GeometryType theType)
+{
+ myElemGeomTypePtr->SetGeomType(SMDSAbs_GeometryType(theType));
+ TPythonDump()<<this<<".SetGeometryType("<<theType<<")";
+}
+
+GeometryType ElemGeomType_i::GetGeometryType() const
+{
+ return (GeometryType)myElemGeomTypePtr->GetGeomType();
+}
+
+FunctorType ElemGeomType_i::GetFunctorType()
+{
+ return SMESH::FT_ElemGeomType;
+}
+
+/*
+ Class : ElemEntityType_i
+ Description : Predicate check is element has indicated entity type
+*/
+ElemEntityType_i::ElemEntityType_i()
+{
+ myElemEntityTypePtr.reset(new Controls::ElemEntityType());
+ myFunctorPtr = myPredicatePtr = myElemEntityTypePtr;
+}
+
+void ElemEntityType_i::SetElementType(ElementType theType)
+{
+ myElemEntityTypePtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+void ElemEntityType_i::SetEntityType(EntityType theEntityType)
+{
+ myElemEntityTypePtr->SetElemEntityType(SMDSAbs_EntityType (theEntityType));
+ TPythonDump()<<this<<".SetEntityType("<<theEntityType<<")";
+}
+EntityType ElemEntityType_i::GetEntityType() const
+{
+ return (EntityType) myElemEntityTypePtr->GetElemEntityType();
+}
+
+FunctorType ElemEntityType_i::GetFunctorType()
+{
+ return SMESH::FT_EntityType;
+}
+
+/*
+ Class : CoplanarFaces_i
+ Description : Returns true if a mesh face is a coplanar neighbour to a given one
+*/
+CoplanarFaces_i::CoplanarFaces_i()
+{
+ myCoplanarFacesPtr.reset(new Controls::CoplanarFaces());
+ myFunctorPtr = myPredicatePtr = myCoplanarFacesPtr;
+}
+
+void CoplanarFaces_i::SetFace ( CORBA::Long theFaceID )
+{
+ myCoplanarFacesPtr->SetFace(theFaceID);
+ TPythonDump()<<this<<".SetFace("<<theFaceID<<")";
+}
+
+void CoplanarFaces_i::SetTolerance( CORBA::Double theToler )
+{
+ myCoplanarFacesPtr->SetTolerance(theToler);
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
+}
+
+CORBA::Long CoplanarFaces_i::GetFace () const
+{
+ return myCoplanarFacesPtr->GetFace();
+}
+
+char* CoplanarFaces_i::GetFaceAsString () const
+{
+ TCollection_AsciiString str(Standard_Integer(myCoplanarFacesPtr->GetFace()));
+ return CORBA::string_dup( str.ToCString() );
+}
+
+CORBA::Double CoplanarFaces_i::GetTolerance() const
+{
+ return myCoplanarFacesPtr->GetTolerance();
+}
+
+FunctorType CoplanarFaces_i::GetFunctorType()
+{
+ return SMESH::FT_CoplanarFaces;
+}
+
+/*
+ * Class : ConnectedElements_i
+ * Description : Returns true if an element is connected via other elements to the element
+ * located at a given point.
+ */
+ConnectedElements_i::ConnectedElements_i()
+{
+ myConnectedElementsPtr.reset(new Controls::ConnectedElements());
+ myFunctorPtr = myPredicatePtr = myConnectedElementsPtr;
+}
+
+FunctorType ConnectedElements_i::GetFunctorType()
+{
+ return FT_ConnectedElements;
+}
+
+void ConnectedElements_i::SetElementType( ElementType theType )
+{
+ myConnectedElementsPtr->SetType( SMDSAbs_ElementType( theType ));
+ TPythonDump() << this << ".SetElementType( " << theType << " )";
+}
+
+void ConnectedElements_i::SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z )
+{
+ myConnectedElementsPtr->SetPoint( x,y,z );
+ myVertexID.clear();
+ TPythonDump() << this << ".SetPoint( " << x << ", " << y << ", " << z << " )";
+}
+
+void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
+ throw (SALOME::SALOME_Exception)
+{
+ TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( vertex );
+ if ( shape.IsNull() )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): NULL Vertex",
+ SALOME::BAD_PARAM );
+
+ TopExp_Explorer v( shape, TopAbs_VERTEX );
+ if ( !v.More() )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): empty vertex",
+ SALOME::BAD_PARAM );
+
+ gp_Pnt p = BRep_Tool::Pnt( TopoDS::Vertex( v.Current() ));
+ myConnectedElementsPtr->SetPoint( p.X(), p.Y(), p.Z() );
+ //
+ CORBA::String_var id = vertex->GetStudyEntry();
+ myVertexID = id.in();
+
+ TPythonDump() << this << ".SetVertex( " << vertex << " )";
+}
+
+void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
+ throw (SALOME::SALOME_Exception)
+{
+ if ( nodeID < 1 )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetNode(): nodeID must be > 0",
+ SALOME::BAD_PARAM );
+
+ myConnectedElementsPtr->SetNode( nodeID );
+ myVertexID.clear();
+ TPythonDump() << this << ".SetNode( " << nodeID << " )";
+}
+
+/*!
+ * \brief This is a comfort method for Filter dialog
+ */
+void ConnectedElements_i::SetThreshold ( const char* threshold,
+ SMESH::ConnectedElements::ThresholdType type )
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !threshold )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetThreshold(): NULL threshold",
+ SALOME::BAD_PARAM );
+ switch ( type )
+ {
+ case SMESH::ConnectedElements::POINT: // read 3 node coordinates ///////////////////
+ {
+ vector< double > xyz;
+ char* endptr;
+ do
+ {
+ // skip a separator
+ while ( *threshold &&
+ *threshold != '+' &&
+ *threshold != '-' &&
+ !isdigit( *threshold ))
+ ++threshold;
+ if ( !*threshold )
+ break;
+ // read a coordinate
+ xyz.push_back( strtod( threshold, &endptr ));
+ if ( threshold == endptr )
+ {
+ xyz.resize( xyz.size() - 1 );
+ break;
+ }
+ threshold = endptr;
+ }
+ while ( xyz.size() < 3 );
+
+ if ( xyz.size() < 3 )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid point coordinates", SALOME::BAD_PARAM );
+
+ SetPoint( xyz[0], xyz[1], xyz[2] );
+ break;
+ }
+ case SMESH::ConnectedElements::VERTEX: // get a VERTEX by its entry /////////////////
+ {
+ SALOMEDS::Study_var study = SMESH_Gen_i::GetSMESHGen()->GetCurrentStudy();
+ if ( study->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): NULL current study", SALOME::BAD_PARAM );
+ SALOMEDS::SObject_wrap sobj = study->FindObjectID( threshold );
+ if ( sobj->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid vertex study entry", SALOME::BAD_PARAM );
+ CORBA::Object_var obj = sobj->GetObject();
+ GEOM::GEOM_Object_wrap vertex = GEOM::GEOM_Object::_narrow( obj );
+ if ( vertex->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): no GEOM_Object in SObject", SALOME::BAD_PARAM );
+ SetVertex( vertex );
+ break;
+ }
+ case SMESH::ConnectedElements::NODE: // read a node ID ////////////////////////////
+ {
+ char* endptr;
+ int id = strtol( threshold, &endptr, 10 );
+ if ( threshold == endptr )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid node ID", SALOME::BAD_PARAM );
+ SetNode( id );
+ break;
+ }
+ default:
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid ThresholdType", SALOME::BAD_PARAM );
+ }
+}
+
+char* ConnectedElements_i::GetThreshold ( SMESH::ConnectedElements::ThresholdType& type )
+{
+ std::string threshold;
+ if ( !myVertexID.empty() )
+ {
+ threshold = myVertexID;
+ type = SMESH::ConnectedElements::VERTEX;
+ }
+ else
+ {
+ std::vector<double> xyz = myConnectedElementsPtr->GetPoint();
+ if ( xyz.size() == 3 )
+ {
+ threshold = SMESH_Comment( xyz[0] ) << "; " << xyz[1] << "; " << xyz[2];
+ type = SMESH::ConnectedElements::POINT;
+ }
+ else
+ {
+ threshold = SMESH_Comment( myConnectedElementsPtr->GetNode() );
+ type = SMESH::ConnectedElements::NODE;
+ }
+ }
+ return CORBA::string_dup( threshold.c_str() );
+}
+