// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
//
// 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
+// 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,
+// 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
+// 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
+//
+// 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
//
//
//
#include "SMESH_Filter_i.hxx"
#include "SMESH_Gen_i.hxx"
+#include "SMESH_PythonDump.hxx"
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshNode.hxx"
using namespace SMESH;
using namespace SMESH::Controls;
+
+namespace SMESH
+{
+ Predicate_i*
+ GetPredicate( Predicate_ptr thePredicate )
+ {
+ return DownCast<Predicate_i*>(thePredicate);
+ }
+}
+
+
/*
Class : BelongToGeom
Description : Predicate for verifying whether entiy belong to
myType(SMDSAbs_All)
{}
-void Controls::BelongToGeom::SetMesh( SMDS_Mesh* theMesh )
+void Controls::BelongToGeom::SetMesh( const SMDS_Mesh* theMesh )
{
- myMeshDS = dynamic_cast<SMESHDS_Mesh*>(theMesh);
+ myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
}
void Controls::BelongToGeom::SetGeom( const TopoDS_Shape& theShape )
myShape = theShape;
}
-static bool IsContains( SMESHDS_Mesh* theMeshDS,
+static bool IsContains( const SMESHDS_Mesh* theMeshDS,
const TopoDS_Shape& theShape,
const SMDS_MeshElement* theElem,
TopAbs_ShapeEnum theFindShapeEnum,
TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE )
{
TopExp_Explorer anExp( theShape,theFindShapeEnum,theAvoidShapeEnum );
-
+
while( anExp.More() )
{
const TopoDS_Shape& aShape = anExp.Current();
}
}
}
-
+
return false;
}
return myShape;
}
-SMESHDS_Mesh* Controls::BelongToGeom::GetMeshDS()
+const SMESHDS_Mesh*
+Controls::BelongToGeom::
+GetMeshDS() const
{
return myMeshDS;
}
myType(SMDSAbs_All)
{}
-void Controls::LyingOnGeom::SetMesh( SMDS_Mesh* theMesh )
+void Controls::LyingOnGeom::SetMesh( const SMDS_Mesh* theMesh )
{
- myMeshDS = dynamic_cast<SMESHDS_Mesh*>(theMesh);
+ myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
}
void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape )
}
}
}
-
+
return false;
}
return myShape;
}
-SMESHDS_Mesh* Controls::LyingOnGeom::GetMeshDS()
+const SMESHDS_Mesh*
+Controls::LyingOnGeom::
+GetMeshDS() const
{
return myMeshDS;
}
-bool Controls::LyingOnGeom::Contains( SMESHDS_Mesh* theMeshDS,
- const TopoDS_Shape& theShape,
- const SMDS_MeshElement* theElem,
- TopAbs_ShapeEnum theFindShapeEnum,
- TopAbs_ShapeEnum theAvoidShapeEnum )
+bool Controls::LyingOnGeom::Contains( const SMESHDS_Mesh* theMeshDS,
+ const TopoDS_Shape& theShape,
+ const SMDS_MeshElement* theElem,
+ TopAbs_ShapeEnum theFindShapeEnum,
+ TopAbs_ShapeEnum theAvoidShapeEnum )
{
if (IsContains(theMeshDS, theShape, theElem, theFindShapeEnum, theAvoidShapeEnum))
return true;
-
+
TopTools_IndexedMapOfShape aSubShapes;
TopExp::MapShapes( theShape, aSubShapes );
-
+
for (int i = 1; i <= aSubShapes.Extent(); i++)
- {
- const TopoDS_Shape& aShape = aSubShapes.FindKey(i);
-
- if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
- if( aSubMesh->Contains( theElem ) )
- return true;
-
- SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
- while ( aNodeIt->more() )
- {
- const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
- SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
- while ( anElemIt->more() )
- {
- const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
- if (anElement == theElem)
- return true;
- }
- }
+ {
+ const TopoDS_Shape& aShape = aSubShapes.FindKey(i);
+
+ if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
+ if( aSubMesh->Contains( theElem ) )
+ return true;
+
+ SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
+ while ( aNodeIt->more() )
+ {
+ const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
+ SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
+ while ( anElemIt->more() )
+ {
+ const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
+ if (anElement == theElem)
+ return true;
+ }
}
}
+ }
return false;
}
AUXILIARY METHODS
*/
-static inline SMDS_Mesh* MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
+inline
+const SMDS_Mesh*
+MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
{
- SMESH_Mesh_i* anImplPtr =
- dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( theMesh ).in() );
+ SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theMesh);
return anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
}
-static inline SMESH::long_array* toArray( const TColStd_ListOfInteger& aList )
+inline
+SMESH::long_array*
+toArray( const TColStd_ListOfInteger& aList )
{
SMESH::long_array_var anArray = new SMESH::long_array;
anArray->length( aList.Extent() );
return anArray._retn();
}
-static inline SMESH::double_array* toArray( const TColStd_ListOfReal& aList )
+inline
+SMESH::double_array*
+toArray( const TColStd_ListOfReal& aList )
{
SMESH::double_array_var anArray = new SMESH::double_array;
anArray->length( aList.Extent() );
aCriterion.UnaryOp = FT_Undefined;
aCriterion.BinaryOp = FT_Undefined;
aCriterion.ThresholdStr = "";
+ aCriterion.ThresholdID = "";
aCriterion.Tolerance = Precision::Confusion();
aCriterion.TypeOfElement = SMESH::ALL;
aCriterion.Precision = -1;
{
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
- if ( aStudy != 0 )
+ if (!CORBA::is_nil(aStudy))
{
SALOMEDS::Study::ListOfSObject_var aList =
aStudy->FindObjectByName( theName, "GEOM" );
GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( aList[ 0 ]->GetObject() );
if ( !aGeomObj->_is_nil() )
{
- GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
+ GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
return aLocShape;
}
return TopoDS_Shape();
}
+static TopoDS_Shape getShapeByID( const char* theID )
+{
+ if ( theID != 0 && theID!="" )
+ {
+ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+ SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
+ if ( aStudy != 0 )
+ {
+ CORBA::Object_var obj = aStudy->ConvertIORToObject(theID);
+ GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( obj );
+
+ if ( !aGeomObj->_is_nil() )
+ {
+ GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
+ TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
+ return aLocShape;
+ }
+ }
+ }
+ return TopoDS_Shape();
+}
+
+static char* getShapeNameByID ( const char* theID )
+{
+ char* aName = "";
+ if ( theID != 0 && theID!="" )
+ {
+ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+ SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
+ if ( aStudy != 0 )
+ {
+ SALOMEDS::SObject_var aSObj = aStudy->FindObjectIOR( theID );
+ SALOMEDS::GenericAttribute_var anAttr;
+ if ( !aSObj->_is_nil() && aSObj->FindAttribute( anAttr, "AttributeName") )
+ {
+ SALOMEDS::AttributeName_var aNameAttr = SALOMEDS::AttributeName::_narrow( anAttr );
+ aName = aNameAttr->Value();
+ }
+ }
+ }
+
+ return aName;
+}
/*
FUNCTORS
/*
Class : Functor_i
- Description : An abstact class for all functors
+ Description : An abstact class for all functors
*/
-Functor_i::Functor_i():
+Functor_i::Functor_i():
SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
- SMESH_Gen_i::GetPOA()->activate_object( this );
+ PortableServer::ObjectId_var anObjectId =
+ SMESH_Gen_i::GetPOA()->activate_object( this );
+}
+
+Functor_i::~Functor_i()
+{
+ //TPythonDump()<<this<<".Destroy()";
}
void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
{
myFunctorPtr->SetMesh( MeshPtr2SMDSMesh( theMesh ) );
- INFOS("Functor_i::SetMesh~");
+ TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
}
ElementType Functor_i::GetElementType()
void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
{
myNumericalFunctorPtr->SetPrecision( thePrecision );
+ TPythonDump()<<this<<".SetPrecision("<<thePrecision<<")";
}
CORBA::Long NumericalFunctor_i::GetPrecision()
return SMESH::FT_Area;
}
+/*
+ Class : Volume3D_i
+ Description : Functor for calculating volume of 3D element
+*/
+Volume3D_i::Volume3D_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::Volume() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType Volume3D_i::GetFunctorType()
+{
+ return SMESH::FT_Volume3D;
+}
+
/*
Class : Length_i
Description : Functor for calculating length off edge
INFOS("Length2D_i::GetValues");
SMESH::Controls::Length2D::TValues aValues;
myLength2DPtr->GetValues( aValues );
-
+
long i = 0, iEnd = aValues.size();
SMESH::Length2D::Values_var aResult = new SMESH::Length2D::Values(iEnd);
{
const SMESH::Controls::Length2D::Value& aVal = *anIter;
SMESH::Length2D::Value &aValue = aResult[ i ];
-
+
aValue.myLength = aVal.myLength;
aValue.myPnt1 = aVal.myPntId[ 0 ];
aValue.myPnt2 = aVal.myPntId[ 1 ];
-
}
INFOS("Length2D_i::GetValuess~");
INFOS("MultiConnection2D_i::GetValues");
SMESH::Controls::MultiConnection2D::MValues aValues;
myMulticonnection2DPtr->GetValues( aValues );
-
+
long i = 0, iEnd = aValues.size();
SMESH::MultiConnection2D::Values_var aResult = new SMESH::MultiConnection2D::Values(iEnd);
{
const SMESH::Controls::MultiConnection2D::Value& aVal = (*anIter).first;
SMESH::MultiConnection2D::Value &aValue = aResult[ i ];
-
+
aValue.myPnt1 = aVal.myPntId[ 0 ];
aValue.myPnt2 = aVal.myPntId[ 1 ];
aValue.myNbConnects = (*anIter).second;
-
}
INFOS("Multiconnection2D_i::GetValuess~");
myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
myShapeName = 0;
+ myShapeID = 0;
}
BelongToGeom_i::~BelongToGeom_i()
{
delete myShapeName;
+ delete myShapeID;
}
void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
myBelongToGeomPtr->SetGeom( aLocShape );
+ TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
}
void BelongToGeom_i::SetGeom( const TopoDS_Shape& theShape )
void BelongToGeom_i::SetElementType(ElementType theType){
myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
FunctorType BelongToGeom_i::GetFunctorType()
delete myShapeName;
myShapeName = strdup( theName );
myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+ TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
+}
+
+void BelongToGeom_i::SetShape( const char* theID, const char* theName )
+{
+ delete myShapeName;
+ myShapeName = strdup( theName );
+ delete myShapeID;
+ if ( theID )
+ myShapeID = strdup( theID );
+ else
+ myShapeID = 0;
+
+ if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
+ myBelongToGeomPtr->SetGeom( getShapeByID(myShapeID) );
+ else
+ myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
}
char* BelongToGeom_i::GetShapeName()
return CORBA::string_dup( myShapeName );
}
+char* BelongToGeom_i::GetShapeID()
+{
+ return CORBA::string_dup( myShapeID );
+}
+
/*
Class : BelongToSurface_i
Description : Predicate for selection on geometrical support
myElementsOnSurfacePtr.reset( new Controls::ElementsOnSurface() );
myFunctorPtr = myPredicatePtr = myElementsOnSurfacePtr;
myShapeName = 0;
+ myShapeID = 0;
mySurfaceType = theSurfaceType;
}
BelongToSurface_i::~BelongToSurface_i()
{
delete myShapeName;
+ delete myShapeID;
}
void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
}
myElementsOnSurfacePtr->SetSurface( TopoDS_Shape(), (SMDSAbs_ElementType)theType );
+ TPythonDump()<<this<<".SetSurface("<<theGeom<<",'"<<theType<<"')";
}
void BelongToSurface_i::SetShapeName( const char* theName, ElementType theType )
delete myShapeName;
myShapeName = strdup( theName );
myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
+ TPythonDump()<<this<<".SetShapeName('"<<theName<<"',"<<theType<<")";
+}
+
+void BelongToSurface_i::SetShape( const char* theID, const char* theName, ElementType theType )
+{
+ delete myShapeName;
+ myShapeName = strdup( theName );
+ delete myShapeID;
+ if ( theID )
+ myShapeID = strdup( theID );
+ else
+ myShapeID = 0;
+
+ if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
+ myElementsOnSurfacePtr->SetSurface( getShapeByID(myShapeID), (SMDSAbs_ElementType)theType );
+ else
+ myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
}
char* BelongToSurface_i::GetShapeName()
return CORBA::string_dup( myShapeName );
}
+char* BelongToSurface_i::GetShapeID()
+{
+ return CORBA::string_dup( myShapeID );
+}
+
void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
{
myElementsOnSurfacePtr->SetTolerance( theToler );
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
}
CORBA::Double BelongToSurface_i::GetTolerance()
void BelongToPlane_i::SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
{
BelongToSurface_i::SetSurface( theGeom, theType );
+ TPythonDump()<<this<<".SetPlane("<<theGeom<<","<<theType<<")";
}
FunctorType BelongToPlane_i::GetFunctorType()
void BelongToCylinder_i::SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
{
BelongToSurface_i::SetSurface( theGeom, theType );
+ TPythonDump()<<this<<".SetCylinder("<<theGeom<<","<<theType<<")";
}
FunctorType BelongToCylinder_i::GetFunctorType()
myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() );
myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr;
myShapeName = 0;
+ myShapeID = 0;
}
LyingOnGeom_i::~LyingOnGeom_i()
{
delete myShapeName;
+ delete myShapeID;
}
void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
myLyingOnGeomPtr->SetGeom( aLocShape );
+ TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
}
void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape )
void LyingOnGeom_i::SetElementType(ElementType theType){
myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
FunctorType LyingOnGeom_i::GetFunctorType()
delete myShapeName;
myShapeName = strdup( theName );
myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+ TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
+}
+
+void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
+{
+ delete myShapeName;
+ myShapeName = strdup( theName );
+ delete myShapeID;
+ if ( theID )
+ myShapeID = strdup( theID );
+ else
+ myShapeID = 0;
+
+ if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
+ myLyingOnGeomPtr->SetGeom( getShapeByID(myShapeID) );
+ else
+ myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
}
char* LyingOnGeom_i::GetShapeName()
return CORBA::string_dup( myShapeName );
}
+char* LyingOnGeom_i::GetShapeID()
+{
+ return CORBA::string_dup( myShapeID );
+}
+
/*
Class : FreeBorders_i
Description : Predicate for free borders
INFOS("FreeEdges_i::GetBorders");
SMESH::Controls::FreeEdges::TBorders aBorders;
myFreeEdgesPtr->GetBoreders( aBorders );
-
+
long i = 0, iEnd = aBorders.size();
- SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders(iEnd);
+ SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders;
+ aResult->length(iEnd);
SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
{
const SMESH::Controls::FreeEdges::Border& aBord = *anIter;
SMESH::FreeEdges::Border &aBorder = aResult[ i ];
-
+
aBorder.myElemId = aBord.myElemId;
aBorder.myPnt1 = aBord.myPntId[ 0 ];
aBorder.myPnt2 = aBord.myPntId[ 1 ];
CORBA::Long iEnd = theIds.length();
for ( CORBA::Long i = 0; i < iEnd; i++ )
myRangeOfIdsPtr->AddToRange( theIds[ i ] );
+ TPythonDump()<<this<<".SetRange("<<theIds<<")";
}
CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
{
+ TPythonDump()<<this<<".SetRangeStr('"<<theRange<<"')";
return myRangeOfIdsPtr->SetRangeStr(
TCollection_AsciiString( (Standard_CString)theRange ) );
}
void RangeOfIds_i::SetElementType( ElementType theType )
{
myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
FunctorType RangeOfIds_i::GetFunctorType()
void Comparator_i::SetMargin( CORBA::Double theValue )
{
myComparatorPtr->SetMargin( theValue );
+ TPythonDump()<<this<<".SetMargin("<<theValue<<")";
}
CORBA::Double Comparator_i::GetMargin()
if ( myNumericalFunctor )
myNumericalFunctor->Destroy();
- myNumericalFunctor = dynamic_cast<NumericalFunctor_i*>( SMESH_Gen_i::GetServant( theFunct ).in() );
+ myNumericalFunctor = DownCast<NumericalFunctor_i*>(theFunct);
if ( myNumericalFunctor )
{
myComparatorPtr->SetNumFunctor( myNumericalFunctor->GetNumericalFunctor() );
myNumericalFunctor->Register();
+ TPythonDump()<<this<<".SetNumFunctor("<<myNumericalFunctor<<")";
}
}
void EqualTo_i::SetTolerance( CORBA::Double theToler )
{
myEqualToPtr->SetTolerance( theToler );
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
}
CORBA::Double EqualTo_i::GetTolerance()
myPredicate->Destroy();
}
-void LogicalNOT_i::SetPredicate( Predicate_ptr thePred )
+void LogicalNOT_i::SetPredicate( Predicate_ptr thePredicate )
{
if ( myPredicate )
myPredicate->Destroy();
- myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePred ).in() );
+ myPredicate = SMESH::GetPredicate(thePredicate);
if ( myPredicate ){
myLogicalNOTPtr->SetPredicate(myPredicate->GetPredicate());
myPredicate->Register();
+ TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
}
}
if ( myPredicate1 )
myPredicate1->Destroy();
- myPredicate1 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+ myPredicate1 = SMESH::GetPredicate(thePredicate);
if ( myPredicate1 ){
myLogicalBinaryPtr->SetPredicate1(myPredicate1->GetPredicate());
myPredicate1->Register();
+ TPythonDump()<<this<<".SetPredicate1("<<myPredicate1<<")";
}
}
if ( myPredicate2 )
myPredicate2->Destroy();
- myPredicate2 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+ myPredicate2 = SMESH::GetPredicate(thePredicate);
if ( myPredicate2 ){
myLogicalBinaryPtr->SetPredicate2(myPredicate2->GetPredicate());
myPredicate2->Register();
+ TPythonDump()<<this<<".SetPredicate2("<<myPredicate2<<")";
}
}
FilterManager_i::FilterManager_i()
: SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
- SMESH_Gen_i::GetPOA()->activate_object( this );
+ PortableServer::ObjectId_var anObjectId =
+ SMESH_Gen_i::GetPOA()->activate_object( this );
}
+
+FilterManager_i::~FilterManager_i()
+{
+ //TPythonDump()<<this<<".Destroy()";
+}
+
+
MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
{
SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
SMESH::MinimumAngle_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMinimumAngle()";
return anObj._retn();
}
{
SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
SMESH::AspectRatio_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio()";
return anObj._retn();
}
{
SMESH::AspectRatio3D_i* aServant = new SMESH::AspectRatio3D_i();
SMESH::AspectRatio3D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio3D()";
return anObj._retn();
}
{
SMESH::Warping_i* aServant = new SMESH::Warping_i();
SMESH::Warping_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateWarping()";
return anObj._retn();
}
{
SMESH::Taper_i* aServant = new SMESH::Taper_i();
SMESH::Taper_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateTaper()";
return anObj._retn();
}
{
SMESH::Skew_i* aServant = new SMESH::Skew_i();
SMESH::Skew_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateSkew()";
return anObj._retn();
}
{
SMESH::Area_i* aServant = new SMESH::Area_i();
SMESH::Area_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateArea()";
+ return anObj._retn();
+}
+
+
+Volume3D_ptr FilterManager_i::CreateVolume3D()
+{
+ SMESH::Volume3D_i* aServant = new SMESH::Volume3D_i();
+ SMESH::Volume3D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateVolume3D()";
return anObj._retn();
}
{
SMESH::Length_i* aServant = new SMESH::Length_i();
SMESH::Length_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLength()";
return anObj._retn();
}
{
SMESH::Length2D_i* aServant = new SMESH::Length2D_i();
SMESH::Length2D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
return anObj._retn();
}
{
SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
SMESH::MultiConnection_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection()";
return anObj._retn();
}
{
SMESH::MultiConnection2D_i* aServant = new SMESH::MultiConnection2D_i();
SMESH::MultiConnection2D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection2D()";
return anObj._retn();
}
{
SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
SMESH::BelongToGeom_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGeom()";
return anObj._retn();
}
{
SMESH::BelongToPlane_i* aServant = new SMESH::BelongToPlane_i();
SMESH::BelongToPlane_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToPlane()";
return anObj._retn();
}
{
SMESH::BelongToCylinder_i* aServant = new SMESH::BelongToCylinder_i();
SMESH::BelongToCylinder_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToCylinder()";
return anObj._retn();
}
{
SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
SMESH::LyingOnGeom_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLyingOnGeom()";
return anObj._retn();
}
{
SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
SMESH::FreeBorders_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFreeBorders()";
return anObj._retn();
}
{
SMESH::FreeEdges_i* aServant = new SMESH::FreeEdges_i();
SMESH::FreeEdges_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFreeEdges()";
return anObj._retn();
}
{
SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
SMESH::RangeOfIds_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateRangeOfIds()";
return anObj._retn();
}
{
SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
SMESH::BadOrientedVolume_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBadOrientedVolume()";
return anObj._retn();
}
{
SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
SMESH::LessThan_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLessThan()";
return anObj._retn();
}
{
SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
SMESH::MoreThan_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMoreThan()";
return anObj._retn();
}
{
SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
SMESH::EqualTo_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateEqualTo()";
return anObj._retn();
}
{
SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
SMESH::LogicalNOT_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalNOT()";
return anObj._retn();
}
{
SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
SMESH::LogicalAND_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalAND()";
return anObj._retn();
}
{
SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
SMESH::LogicalOR_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalOR()";
return anObj._retn();
}
{
SMESH::Filter_i* aServant = new SMESH::Filter_i();
SMESH::Filter_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFilter()";
return anObj._retn();
}
{
SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
SMESH::FilterLibrary_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary("<<aFileName<<")";
return anObj._retn();
}
{
SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i();
SMESH::FilterLibrary_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLibrary()";
return anObj._retn();
}
CORBA::Boolean FilterManager_i::DeleteLibrary( const char* aFileName )
{
+ TPythonDump()<<this<<".DeleteLibrary("<<aFileName<<")";
return remove( aFileName ) ? false : true;
}
{
if ( myPredicate )
myPredicate->Destroy();
+
+ if(!CORBA::is_nil(myMesh))
+ myMesh->Destroy();
+
+ //TPythonDump()<<this<<".Destroy()";
}
//=======================================================================
if ( myPredicate )
myPredicate->Destroy();
- myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+ myPredicate = SMESH::GetPredicate(thePredicate);
if ( myPredicate )
{
myFilter.SetPredicate( myPredicate->GetPredicate() );
myPredicate->Register();
+ TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
}
}
// name : Filter_i::SetMesh
// Purpose : Set mesh
//=======================================================================
-void Filter_i::SetMesh( SMESH_Mesh_ptr theMesh )
+void
+Filter_i::
+SetMesh( SMESH_Mesh_ptr theMesh )
{
- if ( myPredicate )
- myPredicate->SetMesh( theMesh );
+ if(!CORBA::is_nil(theMesh))
+ theMesh->Register();
+
+ if(!CORBA::is_nil(myMesh))
+ myMesh->Destroy();
+
+ myMesh = theMesh;
+ TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
+}
+
+SMESH::long_array*
+Filter_i::
+GetIDs()
+{
+ return GetElementsId(myMesh);
}
//=======================================================================
// name : Filter_i::GetElementsId
// Purpose : Get ids of entities
//=======================================================================
-SMESH::long_array* Filter_i::GetElementsId( SMESH_Mesh_ptr theMesh )
+void
+Filter_i::
+GetElementsId( Predicate_i* thePredicate,
+ const SMDS_Mesh* theMesh,
+ Controls::Filter::TIdSequence& theSequence )
{
- SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh);
- Controls::Filter::TIdSequence aSequence = myFilter.GetElementsId(aMesh);
-
- SMESH::long_array_var anArray = new SMESH::long_array;
- long i = 0, iEnd = aSequence.size();
+ Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
+}
- anArray->length( iEnd );
- for ( ; i < iEnd; i++ )
- anArray[ i ] = aSequence[i];
+void
+Filter_i::
+GetElementsId( Predicate_i* thePredicate,
+ SMESH_Mesh_ptr theMesh,
+ Controls::Filter::TIdSequence& theSequence )
+{
+ if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
+ Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
+}
+SMESH::long_array*
+Filter_i::
+GetElementsId( SMESH_Mesh_ptr theMesh )
+{
+ SMESH::long_array_var anArray = new SMESH::long_array;
+ if(!CORBA::is_nil(theMesh)){
+ Controls::Filter::TIdSequence aSequence;
+ GetElementsId(myPredicate,theMesh,aSequence);
+ long i = 0, iEnd = aSequence.size();
+ anArray->length( iEnd );
+ for ( ; i < iEnd; i++ )
+ anArray[ i ] = aSequence[i];
+ }
return anArray._retn();
}
theCriteria[ i ].Type = FT_BelongToGeom;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
+ theCriteria[ i ].ThresholdID = aPred->GetShapeID();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
return true;
theCriteria[ i ].Type = aFType;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
+ theCriteria[ i ].ThresholdID = aPred->GetShapeID();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
theCriteria[ i ].Tolerance = aPred->GetTolerance();
theCriteria[ i ].Type = FT_LyingOnGeom;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
+ theCriteria[ i ].ThresholdID = aPred->GetShapeID();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
return true;
if ( myPredicate != 0 )
myPredicate->Destroy();
- SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
- FilterManager_ptr aFilterMgr = aFilter->_this();
+ SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
+ FilterManager_ptr aFilterMgr = aFilter->_this();
// CREATE two lists ( PREDICATES and LOG OP )
// Criterion
+ TPythonDump()<<"aCriteria = []";
std::list<SMESH::Predicate_ptr> aPredicates;
std::list<int> aBinaries;
for ( int i = 0, n = theCriteria.length(); i < n; i++ )
int aCriterion = theCriteria[ i ].Type;
int aCompare = theCriteria[ i ].Compare;
double aThreshold = theCriteria[ i ].Threshold;
+ const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
+ const char* aThresholdID = theCriteria[ i ].ThresholdID;
int aUnary = theCriteria[ i ].UnaryOp;
int aBinary = theCriteria[ i ].BinaryOp;
double aTolerance = theCriteria[ i ].Tolerance;
- const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
ElementType aTypeOfElem = theCriteria[ i ].TypeOfElement;
long aPrecision = theCriteria[ i ].Precision;
-
+
+ TPythonDump()<<"aCriteria.append(SMESH.Filter.Criterion("<<
+ aCriterion<<","<<aCompare<<","<<aThreshold<<",'"<<aThresholdStr<<"','"<<aThresholdID<<"',"<<
+ aUnary<<","<<aBinary<<","<<aTolerance<<","<<aTypeOfElem<<","<<aPrecision<<"))";
+
SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
switch ( aCriterion )
{
// Functors
-
+
case SMESH::FT_MultiConnection:
aFunctor = aFilterMgr->CreateMultiConnection();
break;
case SMESH::FT_MultiConnection2D:
- aFunctor = aFilterMgr->CreateMultiConnection2D();
- break;
+ aFunctor = aFilterMgr->CreateMultiConnection2D();
+ break;
case SMESH::FT_Length:
aFunctor = aFilterMgr->CreateLength();
break;
case SMESH::FT_Area:
aFunctor = aFilterMgr->CreateArea();
break;
+ case SMESH::FT_Volume3D:
+ aFunctor = aFilterMgr->CreateVolume3D();
+ break;
// Predicates
{
SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
tmpPred->SetElementType( aTypeOfElem );
- tmpPred->SetShapeName( aThresholdStr );
+ tmpPred->SetShape( aThresholdID, aThresholdStr );
aPredicate = tmpPred;
}
break;
tmpPred = aFilterMgr->CreateBelongToPlane();
else
tmpPred = aFilterMgr->CreateBelongToCylinder();
- tmpPred->SetShapeName( aThresholdStr, aTypeOfElem );
+ tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
tmpPred->SetTolerance( aTolerance );
aPredicate = tmpPred;
}
{
SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
tmpPred->SetElementType( aTypeOfElem );
- tmpPred->SetShapeName( aThresholdStr );
+ tmpPred->SetShape( aThresholdID, aThresholdStr );
aPredicate = tmpPred;
}
- break;
+ break;
case SMESH::FT_RangeOfIds:
{
SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds();
aPredicate = aFilterMgr->CreateBadOrientedVolume();
}
break;
-
+
default:
continue;
}
aBinaries.push_back( aBinary );
} // end of for
+ TPythonDump()<<this<<".SetCriteria(aCriteria)";
// CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
// name : toString
// Purpose : Convert bool to LDOMString
//=======================================================================
-static inline LDOMString toString( const bool val )
+static inline LDOMString toString( CORBA::Boolean val )
{
return val ? "logical not" : "";
}
// name : toString
// Purpose : Convert double to LDOMString
//=======================================================================
-static inline LDOMString toString( const double val )
+static inline LDOMString toString( CORBA::Double val )
{
char a[ 255 ];
sprintf( a, "%e", val );
// name : toString
// Purpose : Convert functor type to LDOMString
//=======================================================================
-static inline LDOMString toString( const long theType )
+static inline LDOMString toString( CORBA::Long theType )
{
switch ( theType )
{
case FT_Taper : return "Taper";
case FT_Skew : return "Skew";
case FT_Area : return "Area";
+ case FT_Volume3D : return "Volume3D";
case FT_BelongToGeom : return "Belong to Geom";
case FT_BelongToPlane : return "Belong to Plane";
case FT_BelongToCylinder: return "Belong to Cylinder";
else if ( theStr.equals( "Taper" ) ) return FT_Taper;
else if ( theStr.equals( "Skew" ) ) return FT_Skew;
else if ( theStr.equals( "Area" ) ) return FT_Area;
+ else if ( theStr.equals( "Volume3D" ) ) return FT_Volume3D;
else if ( theStr.equals( "Belong to Geom" ) ) return FT_BelongToGeom;
else if ( theStr.equals( "Belong to Plane" ) ) return FT_BelongToPlane;
else if ( theStr.equals( "Belong to Cylinder" ) ) return FT_BelongToCylinder;
const char* aSectionName = getSectionName( theType );
if ( strcmp( aSectionName, "" ) == 0 )
return LDOM_Node();
-
+
LDOM_NodeList aSections = theDoc.getElementsByTagName( "section" );
LDOM_Node aNode;
for ( int i = 0, n = aSections.getLength(); i < n; i++ )
for ( CORBA::ULong i = 0, n = aCriteria->length(); i < n; i++ )
{
LDOM_Element aCriterionItem = theDoc.createElement( "criterion" );
-
- aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type ) );
- aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) );
- aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( aCriteria[ i ].Threshold ) );
- aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) );
- aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) );
+ aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type) );
+ aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) );
+ aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( aCriteria[ i ].Threshold ) );
+ aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) );
+ aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) );
+
aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr );
aCriterionItem.setAttribute( ATTR_TOLERANCE , toString( aCriteria[ i ].Tolerance ) );
aCriterionItem.setAttribute( ATTR_ELEMENT_TYPE ,
FilterLibrary_i::~FilterLibrary_i()
{
delete myFileName;
+ //TPythonDump()<<this<<".Destroy()";
}
//=======================================================================
//=======================================================================
Filter_ptr FilterLibrary_i::Copy( const char* theFilterName )
{
- Filter_ptr aRes;
+ Filter_ptr aRes = Filter::_nil();
LDOM_Node aFilter = findFilter( theFilterName, myDoc );
if ( aFilter.isNull() )
return aRes;
std::list<SMESH::Filter::Criterion> aCriteria;
-
+
for ( LDOM_Node aCritNode = aFilter.getFirstChild();
!aCritNode.isNull() ; aCritNode = aCritNode.getNextSibling() )
{
const char* aUnaryStr = aCrit->getAttribute( ATTR_UNARY ).GetString();
const char* aBinaryStr = aCrit->getAttribute( ATTR_BINARY ).GetString();
const char* anElemTypeStr = aCrit->getAttribute( ATTR_ELEMENT_TYPE ).GetString();
-
+
SMESH::Filter::Criterion aCriterion = createCriterion();
aCriterion.Type = toFunctorType( aTypeStr );
aCriterion.Compare = toFunctorType( aCompareStr );
aCriterion.UnaryOp = toFunctorType( aUnaryStr );
aCriterion.BinaryOp = toFunctorType( aBinaryStr );
-
+
aCriterion.TypeOfElement = toElementType( anElemTypeStr );
LDOMString str = aCrit->getAttribute( ATTR_THRESHOLD );
}
else
aCriterion.ThresholdStr = str.GetString();
-
+
aCriteria.push_back( aCriterion );
}
SMESH::Filter::Criteria_var aCriteriaVar = new SMESH::Filter::Criteria;
aCriteriaVar->length( aCriteria.size() );
-
+
CORBA::ULong i = 0;
std::list<SMESH::Filter::Criterion>::iterator anIter = aCriteria.begin();
-
+
for( ; anIter != aCriteria.end(); ++anIter )
aCriteriaVar[ i++ ] = *anIter;
aRes = myFilterMgr->CreateFilter();
aRes->SetCriteria( aCriteriaVar.inout() );
+ TPythonDump()<<this<<".Copy('"<<theFilterName<<"')";
+
return aRes;
}
{
delete myFileName;
myFileName = strdup( theFileName );
+ TPythonDump()<<this<<".SetFileName('"<<theFileName<<"')";
}
//=======================================================================
else
{
aSection.appendChild( aFilterItem );
+ if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
+ TPythonDump()<<this<<".Add('"<<theFilterName<<"',"<<aFilter<<")";
return true;
}
}
// create filter item
Filter_var aFilter = myFilterMgr->CreateFilter();
-
+
LDOM_Element aFilterItem = createFilterItem( theFilterName, aFilter, myDoc );
if ( aFilterItem.isNull() )
return false;
else
{
aSection.appendChild( aFilterItem );
+ TPythonDump()<<this<<".AddEmpty('"<<theFilterName<<"',"<<theType<<")";
return true;
}
}
return false;
aParentNode.removeChild( aFilterNode );
+ TPythonDump()<<this<<".Delete('"<<theFilterName<<"')";
return true;
}
//=======================================================================
-// name : FilterLibrary_i::Replace
+// name : FilterLibrary_i::Replace
// Purpose : Replace existing filter with entry filter.
// IMPORTANT : If filter does not exist it is not created
//=======================================================================
CORBA::Boolean FilterLibrary_i::Replace( const char* theFilterName,
- const char* theNewName,
+ const char* theNewName,
Filter_ptr theFilter )
{
LDOM_Element aFilterItem = findFilter( theFilterName, myDoc );
LDOM_Element aNewItem = createFilterItem( theNewName, theFilter, myDoc );
if ( aNewItem.isNull() )
return false;
- else
+ else
{
aFilterItem.ReplaceElement( aNewItem );
+ if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
+ TPythonDump()<<this<<".Replace('"<<theFilterName<<"',"<<theNewName<<"',"<<aFilter<<")";
return true;
}
}
{
if ( myFileName == 0 || strlen( myFileName ) == 0 )
return false;
-
+
FILE* aOutFile = fopen( myFileName, "wt" );
if ( !aOutFile )
return false;
aWriter << myDoc;
fclose( aOutFile );
+ TPythonDump()<<this<<".Save()";
return true;
}
CORBA::Boolean FilterLibrary_i::SaveAs( const char* aFileName )
{
myFileName = strdup ( aFileName );
+ TPythonDump()<<this<<".SaveAs('"<<aFileName<<"')";
return Save();
}