X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FBLSURFPlugin%2FBLSURFPlugin_Hypothesis_i.cxx;h=0de4975862a613009e043a58bacf5cf333634ffe;hb=dfbdf1950475c847558f7b6c65d0c3e10a16d86b;hp=7eae6dac6190045a1e05b14f92016a9a99afca29;hpb=1e86ea2036c9f115c9073b74ec87d064b9d9082b;p=plugins%2Fblsurfplugin.git diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx index 7eae6da..0de4975 100644 --- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx +++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2014 CEA/DEN, EDF R&D +// Copyright (C) 2007-2016 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -37,6 +37,8 @@ #include #include +using namespace std; + //============================================================================= /*! * BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i @@ -44,11 +46,16 @@ * Constructor */ //============================================================================= -BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA, int theStudyId, - ::SMESH_Gen* theGenImpl) : - SALOME::GenericObj_i(thePOA), SMESH_Hypothesis_i(thePOA) { - MESSAGE( "BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i" ); - myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(), theStudyId, theGenImpl); +BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr thePOA, + int theStudyId, + ::SMESH_Gen* theGenImpl, + bool theHasGEOM) : + SALOME::GenericObj_i(thePOA), SMESH_Hypothesis_i(thePOA) +{ + myBaseImpl = new ::BLSURFPlugin_Hypothesis(theGenImpl->GetANewId(), + theStudyId, + theGenImpl, + theHasGEOM); } //============================================================================= @@ -58,8 +65,8 @@ BLSURFPlugin_Hypothesis_i::BLSURFPlugin_Hypothesis_i(PortableServer::POA_ptr the * Destructor */ //============================================================================= -BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i() { - MESSAGE( "BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i" ); +BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i() +{ } //============================================================================= @@ -72,8 +79,8 @@ BLSURFPlugin_Hypothesis_i::~BLSURFPlugin_Hypothesis_i() { */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhysicalMesh"); +void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue) +{ ASSERT(myBaseImpl); this->GetImpl()->SetPhysicalMesh((::BLSURFPlugin_Hypothesis::PhysicalMesh) theValue); SMESH::TPythonDump() << _this() << ".SetPhysicalMesh( " << theValue << " )"; @@ -86,8 +93,8 @@ void BLSURFPlugin_Hypothesis_i::SetPhysicalMesh(CORBA::Long theValue) { * Get PhysicalMesh */ //============================================================================= -CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhysicalMesh"); +CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh() +{ ASSERT(myBaseImpl); return this->GetImpl()->GetPhysicalMesh(); } @@ -100,8 +107,8 @@ CORBA::Long BLSURFPlugin_Hypothesis_i::GetPhysicalMesh() { */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetGeometricMesh"); +void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue) +{ ASSERT(myBaseImpl); this->GetImpl()->SetGeometricMesh((::BLSURFPlugin_Hypothesis::GeometricMesh) theValue); SMESH::TPythonDump() << _this() << ".SetGeometricMesh( " << theValue << " )"; @@ -114,8 +121,8 @@ void BLSURFPlugin_Hypothesis_i::SetGeometricMesh(CORBA::Long theValue) { * Get GeometricMesh */ //============================================================================= -CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetGeometricMesh"); +CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh() +{ ASSERT(myBaseImpl); return this->GetImpl()->GetGeometricMesh(); } @@ -127,8 +134,8 @@ CORBA::Long BLSURFPlugin_Hypothesis_i::GetGeometricMesh() { * Set PhySize */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue) { -// MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhySize"); +void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue) +{ ASSERT(myBaseImpl); this->GetImpl()->SetPhySize(theValue, false); SMESH::TPythonDump() << _this() << ".SetPhySize( " << theValue << " )"; @@ -141,8 +148,8 @@ void BLSURFPlugin_Hypothesis_i::SetPhySize(CORBA::Double theValue) { * Set Relative PhySize */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue) { -// MESSAGE("BLSURFPlugin_Hypothesis_i::SetPhySizeRel"); +void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue) +{ ASSERT(myBaseImpl); this->GetImpl()->SetPhySize(theValue, true); SMESH::TPythonDump() << _this() << ".SetPhySizeRel( " << theValue << " )"; @@ -155,8 +162,8 @@ void BLSURFPlugin_Hypothesis_i::SetPhySizeRel(CORBA::Double theValue) { * Get PhySize */ //============================================================================= -CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize() { -// MESSAGE("BLSURFPlugin_Hypothesis_i::GetPhySize"); +CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize() +{ ASSERT(myBaseImpl); return this->GetImpl()->GetPhySize(); } @@ -168,15 +175,15 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetPhySize() { * Returns True if PhySize is relative */ //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsPhySizeRel() { -// MESSAGE("BLSURFPlugin_Hypothesis_i::IsPhySizeRel"); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsPhySizeRel() +{ ASSERT(myBaseImpl); return this->GetImpl()->IsPhySizeRel(); } //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize) { - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize) +{ if (IsMinSizeRel() || GetMinSize() != theMinSize ) { this->GetImpl()->SetMinSize(theMinSize, false); SMESH::TPythonDump() << _this() << ".SetMinSize( " << theMinSize << " )"; @@ -184,8 +191,8 @@ void BLSURFPlugin_Hypothesis_i::SetMinSize(CORBA::Double theMinSize) { } //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize) { - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize) +{ if ( !IsMinSizeRel() || (GetMinSize() != theMinSize) ) { this->GetImpl()->SetMinSize(theMinSize, true); SMESH::TPythonDump() << _this() << ".SetMinSizeRel( " << theMinSize << " )"; @@ -193,21 +200,20 @@ void BLSURFPlugin_Hypothesis_i::SetMinSizeRel(CORBA::Double theMinSize) { } //============================================================================= -CORBA::Double BLSURFPlugin_Hypothesis_i::GetMinSize() { - ASSERT(myBaseImpl); +CORBA::Double BLSURFPlugin_Hypothesis_i::GetMinSize() +{ return this->GetImpl()->GetMinSize(); } //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMinSizeRel() { -// MESSAGE("BLSURFPlugin_Hypothesis_i::IsMinSizeRel"); - ASSERT(myBaseImpl); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMinSizeRel() +{ return this->GetImpl()->IsMinSizeRel(); } //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize) { - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize) +{ if (IsMaxSizeRel() || GetMaxSize() != theMaxSize) { this->GetImpl()->SetMaxSize(theMaxSize, false); SMESH::TPythonDump() << _this() << ".SetMaxSize( " << theMaxSize << " )"; @@ -215,8 +221,8 @@ void BLSURFPlugin_Hypothesis_i::SetMaxSize(CORBA::Double theMaxSize) { } //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize) { - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize) +{ if ( !IsMaxSizeRel() || (GetMaxSize() != theMaxSize) ) { this->GetImpl()->SetMaxSize(theMaxSize, true); SMESH::TPythonDump() << _this() << ".SetMaxSizeRel( " << theMaxSize << " )"; @@ -224,18 +230,47 @@ void BLSURFPlugin_Hypothesis_i::SetMaxSizeRel(CORBA::Double theMaxSize) { } //============================================================================= -CORBA::Double BLSURFPlugin_Hypothesis_i::GetMaxSize() { - ASSERT(myBaseImpl); +CORBA::Double BLSURFPlugin_Hypothesis_i::GetMaxSize() +{ return this->GetImpl()->GetMaxSize(); } //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel() { -// MESSAGE("BLSURFPlugin_Hypothesis_i::IsMaxSizeRel"); - ASSERT(myBaseImpl); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel() +{ return this->GetImpl()->IsMaxSizeRel(); } + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetUseGradation + * + * Set true or false + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetUseGradation(CORBA::Boolean theValue) +{ + if ( GetImpl()->GetUseGradation() != bool( theValue )) + { + this->GetImpl()->SetUseGradation(theValue); + std::string theValueStr = theValue ? "True" : "False"; + SMESH::TPythonDump() << _this() << ".SetUseGradation( " << theValueStr.c_str() << " )"; + } +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetUseGradation + * + * Get true or false + */ +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseGradation() +{ + return this->GetImpl()->GetUseGradation(); +} + //============================================================================= /*! * BLSURFPlugin_Hypothesis_i::SetGradation @@ -243,11 +278,14 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::IsMaxSizeRel() { * Set Gradation */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetGradation"); - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue) +{ this->GetImpl()->SetGradation(theValue); - SMESH::TPythonDump() << _this() << ".SetGradation( " << theValue << " )"; + + if ( theValue < 0 ) + SetUseGradation( false ); + else + SMESH::TPythonDump() << _this() << ".SetGradation( " << theValue << " )"; } //============================================================================= @@ -257,38 +295,109 @@ void BLSURFPlugin_Hypothesis_i::SetGradation(CORBA::Double theValue) { * Get Gradation */ //============================================================================= -CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetGradation"); - ASSERT(myBaseImpl); +CORBA::Double BLSURFPlugin_Hypothesis_i::GetGradation() +{ return this->GetImpl()->GetGradation(); } //============================================================================= /*! - * BLSURFPlugin_Hypothesis_i::SetQuadAllowed + * BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation * * Set true or false */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetQuadAllowed"); - ASSERT(myBaseImpl); - this->GetImpl()->SetQuadAllowed(theValue); - std::string theValueStr = theValue ? "True" : "False"; - SMESH::TPythonDump() << _this() << ".SetQuadAllowed( " << theValueStr.c_str() << " )"; +void BLSURFPlugin_Hypothesis_i::SetUseVolumeGradation(CORBA::Boolean theValue) +{ + if ( GetImpl()->GetUseVolumeGradation() != bool( theValue )) + { + this->GetImpl()->SetUseVolumeGradation(theValue); + std::string theValueStr = theValue ? "True" : "False"; + SMESH::TPythonDump() << _this() << ".SetUseVolumeGradation( " << theValueStr.c_str() << " )"; + } } //============================================================================= /*! - * BLSURFPlugin_Hypothesis_i::GetQuadAllowed + * BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation * * Get true or false */ //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetQuadAllowed"); - ASSERT(myBaseImpl); - return this->GetImpl()->GetQuadAllowed(); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeGradation() +{ + return this->GetImpl()->GetUseVolumeGradation(); +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetVolumeGradation + * + * Set VolumeGradation + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetVolumeGradation(CORBA::Double theValue) +{ + this->GetImpl()->SetVolumeGradation(theValue); + if ( theValue < 0 ) + SetUseVolumeGradation( false ); + else + SMESH::TPythonDump() << _this() << ".SetVolumeGradation( " << theValue << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetVolumeGradation + * + * Get VolumeGradation + */ +//============================================================================= +CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeGradation() +{ + return this->GetImpl()->GetVolumeGradation(); +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetQuadAllowed + * + * Set true or false + * + * DEPRACATED, kept for python script compatibility + * + * TO be removed in Salome 9 + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetQuadAllowed(CORBA::Boolean theValue) +{ + ::BLSURFPlugin_Hypothesis::ElementType theElementType = theValue ? + ::BLSURFPlugin_Hypothesis::QuadrangleDominant : ::BLSURFPlugin_Hypothesis::Triangles; + this->GetImpl()->SetElementType(theElementType); + SMESH::TPythonDump() << _this() << ".SetElementType( " << theElementType << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetElementType + * + * Set ElementType + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetElementType(CORBA::Long theValue) +{ + this->GetImpl()->SetElementType((::BLSURFPlugin_Hypothesis::ElementType) theValue); + SMESH::TPythonDump() << _this() << ".SetElementType( " << theValue << " )"; +} +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetElementType + * + * Get ElementType + */ +//============================================================================= +CORBA::Long BLSURFPlugin_Hypothesis_i::GetElementType() +{ + return this->GetImpl()->GetElementType(); } //============================================================================= @@ -298,9 +407,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadAllowed() { * Set AngleMesh */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAngleMesh"); - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue) +{ this->GetImpl()->SetAngleMesh(theValue); SMESH::TPythonDump() << _this() << ".SetAngleMesh( " << theValue << " )"; } @@ -312,9 +420,8 @@ void BLSURFPlugin_Hypothesis_i::SetAngleMesh(CORBA::Double theValue) { * Get AngleMesh */ //============================================================================= -CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAngleMesh"); - ASSERT(myBaseImpl); +CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh() +{ return this->GetImpl()->GetAngleMesh(); } @@ -325,9 +432,8 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetAngleMesh() { * Set Chordal Error */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetChordalError"); - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue) +{ this->GetImpl()->SetChordalError(theValue); SMESH::TPythonDump() << _this() << ".SetChordalError( " << theValue << " )"; } @@ -339,9 +445,8 @@ void BLSURFPlugin_Hypothesis_i::SetChordalError(CORBA::Double theValue) { * Get Chordal Error */ //============================================================================= -CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetChordalError"); - ASSERT(myBaseImpl); +CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError() +{ return this->GetImpl()->GetChordalError(); } @@ -352,9 +457,8 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetChordalError() { * Set true or false */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAnisotropic"); - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue) +{ this->GetImpl()->SetAnisotropic(theValue); std::string theValueStr = theValue ? "True" : "False"; SMESH::TPythonDump() << _this() << ".SetAnisotropic( " << theValueStr.c_str() << " )"; @@ -367,9 +471,8 @@ void BLSURFPlugin_Hypothesis_i::SetAnisotropic(CORBA::Boolean theValue) { * Get true or false */ //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAnisotropic"); - ASSERT(myBaseImpl); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic() +{ return this->GetImpl()->GetAnisotropic(); } @@ -380,9 +483,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetAnisotropic() { * Set Anisotropic Ratio */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio"); - ASSERT(myBaseImpl); +void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue) +{ this->GetImpl()->SetAnisotropicRatio(theValue); SMESH::TPythonDump() << _this() << ".SetAnisotropicRatio( " << theValue << " )"; } @@ -394,9 +496,8 @@ void BLSURFPlugin_Hypothesis_i::SetAnisotropicRatio(CORBA::Double theValue) { * Get Anisotropic Ratio */ //============================================================================= -CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio"); - ASSERT(myBaseImpl); +CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio() +{ return this->GetImpl()->GetAnisotropicRatio(); } @@ -409,7 +510,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetAnisotropicRatio() { */ //============================================================================= void BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges"); ASSERT(myBaseImpl); this->GetImpl()->SetRemoveTinyEdges(theValue); std::string theValueStr = theValue ? "True" : "False"; @@ -424,7 +524,6 @@ void BLSURFPlugin_Hypothesis_i::SetRemoveTinyEdges(CORBA::Boolean theValue) { */ //============================================================================= CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges"); ASSERT(myBaseImpl); return this->GetImpl()->GetRemoveTinyEdges(); } @@ -437,7 +536,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRemoveTinyEdges() { */ //============================================================================= void BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength(CORBA::Double theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength"); ASSERT(myBaseImpl); this->GetImpl()->SetTinyEdgeLength(theValue); SMESH::TPythonDump() << _this() << ".SetTinyEdgeLength( " << theValue << " )"; @@ -451,11 +549,112 @@ void BLSURFPlugin_Hypothesis_i::SetTinyEdgeLength(CORBA::Double theValue) { */ //============================================================================= CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength"); ASSERT(myBaseImpl); return this->GetImpl()->GetTinyEdgeLength(); } +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges + * + * Set true or false + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetOptimiseTinyEdges(CORBA::Boolean theValue) { + ASSERT(myBaseImpl); + this->GetImpl()->SetOptimiseTinyEdges(theValue); + std::string theValueStr = theValue ? "True" : "False"; + SMESH::TPythonDump() << _this() << ".SetOptimiseTinyEdges( " << theValueStr.c_str() << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges + * + * Get true or false + */ +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimiseTinyEdges() { + ASSERT(myBaseImpl); + return this->GetImpl()->GetOptimiseTinyEdges(); +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength + * + * Set Tiny Edge OptimisationLength + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetTinyEdgeOptimisationLength(CORBA::Double theValue) { + ASSERT(myBaseImpl); + this->GetImpl()->SetTinyEdgeOptimisationLength(theValue); + SMESH::TPythonDump() << _this() << ".SetTinyEdgeOptimisationLength( " << theValue << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength + * + * Get Tiny Edge OptimisationLength + */ +//============================================================================= +CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeOptimisationLength() { + ASSERT(myBaseImpl); + return this->GetImpl()->GetTinyEdgeOptimisationLength(); +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection + * + * Set true or false + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersection(CORBA::Boolean theValue) { + ASSERT(myBaseImpl); + this->GetImpl()->SetCorrectSurfaceIntersection(theValue); + std::string theValueStr = theValue ? "True" : "False"; + SMESH::TPythonDump() << _this() << ".SetCorrectSurfaceIntersection( " << theValueStr.c_str() << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection + * + * Get true or false + */ +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersection() { + ASSERT(myBaseImpl); + return this->GetImpl()->GetCorrectSurfaceIntersection(); +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost + * + * Set Tiny Edge OptimisationLength + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetCorrectSurfaceIntersectionMaxCost(CORBA::Double theValue) { + ASSERT(myBaseImpl); + this->GetImpl()->SetCorrectSurfaceIntersectionMaxCost(theValue); + SMESH::TPythonDump() << _this() << ".SetCorrectSurfaceIntersectionMaxCost( " << theValue << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost + * + * Get Tiny Edge OptimisationLength + */ +//============================================================================= +CORBA::Double BLSURFPlugin_Hypothesis_i::GetCorrectSurfaceIntersectionMaxCost() { + ASSERT(myBaseImpl); + return this->GetImpl()->GetCorrectSurfaceIntersectionMaxCost(); +} + //============================================================================= /*! * BLSURFPlugin_Hypothesis_i::SetBadElementRemoval @@ -464,7 +663,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetTinyEdgeLength() { */ //============================================================================= void BLSURFPlugin_Hypothesis_i::SetBadElementRemoval(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetBadElementRemoval"); ASSERT(myBaseImpl); this->GetImpl()->SetBadElementRemoval(theValue); std::string theValueStr = theValue ? "True" : "False"; @@ -479,7 +677,6 @@ void BLSURFPlugin_Hypothesis_i::SetBadElementRemoval(CORBA::Boolean theValue) { */ //============================================================================= CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetBadElementRemoval() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetBadElementRemoval"); ASSERT(myBaseImpl); return this->GetImpl()->GetBadElementRemoval(); } @@ -492,7 +689,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetBadElementRemoval() { */ //============================================================================= void BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio(CORBA::Double theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio"); ASSERT(myBaseImpl); this->GetImpl()->SetBadElementAspectRatio(theValue); SMESH::TPythonDump() << _this() << ".SetBadElementAspectRatio( " << theValue << " )"; @@ -506,7 +702,6 @@ void BLSURFPlugin_Hypothesis_i::SetBadElementAspectRatio(CORBA::Double theValue) */ //============================================================================= CORBA::Double BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio"); ASSERT(myBaseImpl); return this->GetImpl()->GetBadElementAspectRatio(); } @@ -519,7 +714,6 @@ CORBA::Double BLSURFPlugin_Hypothesis_i::GetBadElementAspectRatio() { */ //============================================================================= void BLSURFPlugin_Hypothesis_i::SetOptimizeMesh(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetOptimizeMesh"); ASSERT(myBaseImpl); this->GetImpl()->SetOptimizeMesh(theValue); std::string theValueStr = theValue ? "True" : "False"; @@ -534,7 +728,6 @@ void BLSURFPlugin_Hypothesis_i::SetOptimizeMesh(CORBA::Boolean theValue) { */ //============================================================================= CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimizeMesh() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetOptimizeMesh"); ASSERT(myBaseImpl); return this->GetImpl()->GetOptimizeMesh(); } @@ -547,7 +740,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetOptimizeMesh() { */ //============================================================================= void BLSURFPlugin_Hypothesis_i::SetQuadraticMesh(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetQuadraticMesh"); ASSERT(myBaseImpl); this->GetImpl()->SetQuadraticMesh(theValue); std::string theValueStr = theValue ? "True" : "False"; @@ -562,7 +754,6 @@ void BLSURFPlugin_Hypothesis_i::SetQuadraticMesh(CORBA::Boolean theValue) { */ //============================================================================= CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadraticMesh() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetQuadraticMesh"); ASSERT(myBaseImpl); return this->GetImpl()->GetQuadraticMesh(); } @@ -579,7 +770,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetQuadraticMesh() { //============================================================================= void BLSURFPlugin_Hypothesis_i::SetTopology(CORBA::Long theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetTopology"); ASSERT(myBaseImpl); this->GetImpl()->SetTopology((::BLSURFPlugin_Hypothesis::Topology) theValue); SMESH::TPythonDump() << _this() << ".SetTopology( " << theValue << " )"; @@ -593,7 +783,6 @@ void BLSURFPlugin_Hypothesis_i::SetTopology(CORBA::Long theValue) { */ //============================================================================= CORBA::Long BLSURFPlugin_Hypothesis_i::GetTopology() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetTopology"); ASSERT(myBaseImpl); return this->GetImpl()->GetTopology(); } @@ -615,59 +804,399 @@ CORBA::Short BLSURFPlugin_Hypothesis_i::GetVerbosity() { } //============================================================================= -/*! - * BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges - * - * Set true or false - */ +void BLSURFPlugin_Hypothesis_i::SetEnforceCadEdgesSize( CORBA::Boolean toEnforce ) +{ + if ( GetEnforceCadEdgesSize() != toEnforce ) + { + this->GetImpl()->SetEnforceCadEdgesSize(toEnforce); + SMESH::TPythonDump() << _this() << ".SetEnforceCadEdgesSize( " << toEnforce << " )"; + } +} //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges"); - ASSERT(myBaseImpl); - this->GetImpl()->SetPreCADMergeEdges(theValue); - std::string theValueStr = theValue ? "True" : "False"; - SMESH::TPythonDump() << _this() << ".SetPreCADMergeEdges( " << theValueStr.c_str() << " )"; +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetEnforceCadEdgesSize() +{ + return this->GetImpl()->GetEnforceCadEdgesSize(); } - //============================================================================= -/*! - * BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges - * - * Get true or false - */ + +void BLSURFPlugin_Hypothesis_i::SetJacobianRectificationRespectGeometry( CORBA::Boolean allowRectification ) +{ + if ( GetJacobianRectificationRespectGeometry() != allowRectification ) + { + this->GetImpl()->SetJacobianRectificationRespectGeometry(allowRectification); + SMESH::TPythonDump() << _this() << ".SetJacobianRectificationRespectGeometry( " << allowRectification << " )"; + } +} //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges"); - ASSERT(myBaseImpl); - return this->GetImpl()->GetPreCADMergeEdges(); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetJacobianRectificationRespectGeometry() +{ + return this->GetImpl()->GetJacobianRectificationRespectGeometry(); } - //============================================================================= -/*! - * BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology - * - * Set true or false - */ + +void BLSURFPlugin_Hypothesis_i::SetJacobianRectification( CORBA::Boolean allowRectification ) +{ + if ( GetJacobianRectification() != allowRectification ) + { + this->GetImpl()->SetJacobianRectification(allowRectification); + SMESH::TPythonDump() << _this() << ".SetJacobianRectification( " << allowRectification << " )"; + } +} //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology"); - ASSERT(myBaseImpl); - this->GetImpl()->SetPreCADProcess3DTopology(theValue); - std::string theValueStr = theValue ? "True" : "False"; - SMESH::TPythonDump() << _this() << ".SetPreCADProcess3DTopology( " << theValueStr.c_str() << " )"; +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetJacobianRectification() +{ + return this->GetImpl()->GetJacobianRectification(); } - //============================================================================= -/*! - * BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology - * - * Get true or false - */ + +void BLSURFPlugin_Hypothesis_i::SetUseDeprecatedPatchMesher( CORBA::Boolean useDeprecatedPatchMesher ) +{ + if ( GetUseDeprecatedPatchMesher() != useDeprecatedPatchMesher ) + { + this->GetImpl()->SetUseDeprecatedPatchMesher(useDeprecatedPatchMesher); + SMESH::TPythonDump() << _this() << ".SetUseDeprecatedPatchMesher( " << useDeprecatedPatchMesher << " )"; + } +} //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology"); - ASSERT(myBaseImpl); - return this->GetImpl()->GetPreCADProcess3DTopology(); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseDeprecatedPatchMesher() +{ + return this->GetImpl()->GetUseDeprecatedPatchMesher(); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfPointsPerPatch( CORBA::Long nb ) throw (SALOME::SALOME_Exception) +{ + if ( GetMaxNumberOfPointsPerPatch() != nb ) + { + try { + this->GetImpl()->SetMaxNumberOfPointsPerPatch(nb); + + } catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + SMESH::TPythonDump() << _this() << ".SetMaxNumberOfPointsPerPatch( " << nb << " )"; + } +} +//============================================================================= +CORBA::Long BLSURFPlugin_Hypothesis_i::GetMaxNumberOfPointsPerPatch() +{ + return this->GetImpl()->GetMaxNumberOfPointsPerPatch(); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetMaxNumberOfThreads( CORBA::Long nb ) throw (SALOME::SALOME_Exception) +{ + if ( GetMaxNumberOfThreads() != nb ) + { + try { + this->GetImpl()->SetMaxNumberOfThreads(nb); + + } catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + SMESH::TPythonDump() << _this() << ".SetMaxNumberOfThreads( " << nb << " )"; + } +} +//============================================================================= +CORBA::Long BLSURFPlugin_Hypothesis_i::GetMaxNumberOfThreads() +{ + return this->GetImpl()->GetMaxNumberOfThreads(); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetRespectGeometry( CORBA::Boolean toRespect ) +{ + if ( GetRespectGeometry() != toRespect ) + { + this->GetImpl()->SetRespectGeometry(toRespect); + SMESH::TPythonDump() << _this() << ".SetRespectGeometry( " << toRespect << " )"; + } +} +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetRespectGeometry() +{ + return this->GetImpl()->GetRespectGeometry(); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetTinyEdgesAvoidSurfaceIntersections( CORBA::Boolean toAvoidIntersection ) +{ + if ( GetTinyEdgesAvoidSurfaceIntersections() != toAvoidIntersection ) + { + this->GetImpl()->SetTinyEdgesAvoidSurfaceIntersections(toAvoidIntersection); + SMESH::TPythonDump() << _this() << ".SetTinyEdgesAvoidSurfaceIntersections( " << toAvoidIntersection << " )"; + } +} +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetTinyEdgesAvoidSurfaceIntersections() +{ + return this->GetImpl()->GetTinyEdgesAvoidSurfaceIntersections(); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetClosedGeometry( CORBA::Boolean isClosed ) +{ + if ( GetClosedGeometry() != isClosed ) + { + this->GetImpl()->SetClosedGeometry(isClosed); + SMESH::TPythonDump() << _this() << ".SetClosedGeometry( " << isClosed << " )"; + } +} +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetClosedGeometry() +{ + return this->GetImpl()->GetClosedGeometry(); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetDebug( CORBA::Boolean isDebug ) +{ + if ( GetDebug() != isDebug ) + { + this->GetImpl()->SetDebug(isDebug); + SMESH::TPythonDump() << _this() << ".SetDebug( " << isDebug << " )"; + } +} +//============================================================================= +bool BLSURFPlugin_Hypothesis_i::GetDebug() +{ + return this->GetImpl()->GetDebug(); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetPeriodicTolerance( CORBA::Double tol ) throw (SALOME::SALOME_Exception) +{ + bool isDefault; + if ( GetImpl()->GetPreCADOptionValue("periodic_tolerance",&isDefault) != SMESH_Comment( tol )) + { + try + { + this->GetImpl()->SetPeriodicTolerance(tol); + + } catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + SMESH::TPythonDump() << _this() << ".SetPeriodicTolerance( " << tol << " )"; + } +} +//============================================================================= +double BLSURFPlugin_Hypothesis_i::GetPeriodicTolerance() throw (SALOME::SALOME_Exception) +{ + try{ + return this->GetImpl()->GetPeriodicTolerance(); + + } catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + return -1; +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetRequiredEntities( const char* howToTreat ) throw (SALOME::SALOME_Exception) +{ + if ( GetImpl()->GetRequiredEntities() != howToTreat ) + { + try { + this->GetImpl()->SetRequiredEntities(howToTreat); + + } catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + SMESH::TPythonDump() << _this() << ".SetRequiredEntities( '" << howToTreat << "' )"; + } +} +//============================================================================= +char* BLSURFPlugin_Hypothesis_i::GetRequiredEntities() +{ + return CORBA::string_dup( this->GetImpl()->GetRequiredEntities().c_str() ); +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetSewingTolerance( CORBA::Double tol ) throw (SALOME::SALOME_Exception) +{ + bool isDefault; + if ( GetImpl()->GetPreCADOptionValue("sewing_tolerance",&isDefault) != SMESH_Comment( tol )) + { + try + { + this->GetImpl()->SetSewingTolerance(tol); + SMESH::TPythonDump() << _this() << ".SetSewingTolerance( " << tol << " )"; + + } catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + } +} +//============================================================================= +CORBA::Double BLSURFPlugin_Hypothesis_i::GetSewingTolerance() throw (SALOME::SALOME_Exception) +{ + try + { + return this->GetImpl()->GetSewingTolerance(); + + } catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + return -1; +} +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetTags( const char* howToTreat ) throw (SALOME::SALOME_Exception) +{ + if ( GetImpl()->GetTags() != howToTreat ) + { + try { + this->GetImpl()->SetTags(howToTreat); + } + catch (const std::invalid_argument& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + } + SMESH::TPythonDump() << _this() << ".SetTags( '" << howToTreat << "' )"; +} +//============================================================================= +char* BLSURFPlugin_Hypothesis_i::GetTags() +{ + return CORBA::string_dup( this->GetImpl()->GetTags().c_str() ); +} + +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetHyperPatches(const BLSURFPlugin::THyperPatchList& hpl) +{ + ::BLSURFPlugin_Hypothesis::THyperPatchList patchList( hpl.length() ); + SMESH_Comment hplDump; + hplDump << "["; + for ( size_t i = 0; i < patchList.size(); ++i ) + { + hplDump << "[ "; + BLSURFPlugin::THyperPatch tags = hpl[ i ]; + for ( CORBA::ULong j = 0; j < tags.length(); ++j ) + { + patchList[ i ].insert( tags[ j ]); + hplDump << tags[ j ] << ( j+1 < tags.length() ? ", " : " ]" ); + } + hplDump << ( i+1 < patchList.size() ? "," : "]"); + } + if ( GetImpl()->GetHyperPatches() != patchList ) + { + GetImpl()->SetHyperPatches( patchList ); + SMESH::TPythonDump() << _this() << ".SetHyperPatches( " << hplDump << " )"; + } +} + +//============================================================================= +BLSURFPlugin::THyperPatchList* BLSURFPlugin_Hypothesis_i::GetHyperPatches() +{ + const ::BLSURFPlugin_Hypothesis::THyperPatchList& hpl = GetImpl()->GetHyperPatches(); + BLSURFPlugin::THyperPatchList* resHpl = new BLSURFPlugin::THyperPatchList(); + resHpl->length( hpl.size() ); + + ::BLSURFPlugin_Hypothesis::THyperPatchList::const_iterator hpIt = hpl.begin(); + for ( int i = 0; hpIt != hpl.end(); ++hpIt, ++i ) + { + const ::BLSURFPlugin_Hypothesis::THyperPatchTags& hp = *hpIt; + BLSURFPlugin::THyperPatch& resHp = (*resHpl)[ i ]; + resHp.length( hp.size() ); + + ::BLSURFPlugin_Hypothesis::THyperPatchTags::const_iterator tag = hp.begin(); + for ( int j = 0; tag != hp.end(); ++tag, ++j ) + resHp[ j ] = *tag; + } + return resHpl; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges + * + * Set true or false + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetPreCADMergeEdges(CORBA::Boolean theValue) { + ASSERT(myBaseImpl); + this->GetImpl()->SetPreCADMergeEdges(theValue); + std::string theValueStr = theValue ? "True" : "False"; + SMESH::TPythonDump() << _this() << ".SetPreCADMergeEdges( " << theValueStr.c_str() << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges + * + * Get true or false + */ +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADMergeEdges() { + ASSERT(myBaseImpl); + return this->GetImpl()->GetPreCADMergeEdges(); +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces + * + * Set true or false + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveDuplicateCADFaces(CORBA::Boolean theValue) { + ASSERT(myBaseImpl); + this->GetImpl()->SetPreCADRemoveDuplicateCADFaces(theValue); + std::string theValueStr = theValue ? "True" : "False"; + SMESH::TPythonDump() << _this() << ".SetPreCADRemoveDuplicateCADFaces( " << theValueStr.c_str() << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces + * + * Get true or false + */ +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveDuplicateCADFaces() { + ASSERT(myBaseImpl); + return this->GetImpl()->GetPreCADRemoveDuplicateCADFaces(); +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology + * + * Set true or false + */ +//============================================================================= +void BLSURFPlugin_Hypothesis_i::SetPreCADProcess3DTopology(CORBA::Boolean theValue) { + ASSERT(myBaseImpl); + this->GetImpl()->SetPreCADProcess3DTopology(theValue); + std::string theValueStr = theValue ? "True" : "False"; + SMESH::TPythonDump() << _this() << ".SetPreCADProcess3DTopology( " << theValueStr.c_str() << " )"; +} + +//============================================================================= +/*! + * BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology + * + * Get true or false + */ +//============================================================================= +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology() { + ASSERT(myBaseImpl); + return this->GetImpl()->GetPreCADProcess3DTopology(); } //============================================================================= @@ -678,7 +1207,6 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADProcess3DTopology() { */ //============================================================================= void BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput(CORBA::Boolean theValue) { - // MESSAGE("BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput"); ASSERT(myBaseImpl); this->GetImpl()->SetPreCADDiscardInput(theValue); std::string theValueStr = theValue ? "True" : "False"; @@ -693,7 +1221,6 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADDiscardInput(CORBA::Boolean theValue) { */ //============================================================================= CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput"); ASSERT(myBaseImpl); return this->GetImpl()->GetPreCADDiscardInput(); } @@ -702,44 +1229,179 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADDiscardInput() { //============================================================================= void BLSURFPlugin_Hypothesis_i::SetOptionValue(const char* optionName, const char* optionValue) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); - bool valueChanged = false; try { - valueChanged = (this->GetImpl()->GetOptionValue(optionName) != optionValue); - if (valueChanged) - this->GetImpl()->SetOptionValue(optionName, optionValue); + std::string name( optionName ); + if ( !optionValue || !optionValue[0] ) + UnsetOption( optionName ); + + // basic options (visible in Advanced table) + + else if ( name == "enforce_cad_edge_sizes" ) + SetEnforceCadEdgesSize( GetImpl()->ToBool( optionValue )); + + else if ( name == "jacobian_rectification_respect_geometry" ) + SetJacobianRectificationRespectGeometry( GetImpl()->ToBool( optionValue )); + + else if ( name == "max_number_of_points_per_patch" ) + SetMaxNumberOfPointsPerPatch( GetImpl()->ToInt( optionValue )); + + else if ( name == "max_number_of_threads" ) + SetMaxNumberOfThreads( GetImpl()->ToInt( optionValue )); + + else if ( name == "rectify_jacobian" ) + SetJacobianRectification( GetImpl()->ToBool( optionValue )); + + else if ( name == "use_deprecated_patch_mesher" ) + SetUseDeprecatedPatchMesher( GetImpl()->ToBool( optionValue )); + + else if ( name == "respect_geometry" ) + SetRespectGeometry( GetImpl()->ToBool( optionValue )); + + else if ( name == "tiny_edge_avoid_surface_intersections" ) + SetTinyEdgesAvoidSurfaceIntersections( GetImpl()->ToBool( optionValue )); + + else if ( name == "closed_geometry" ) + SetClosedGeometry( GetImpl()->ToBool( optionValue )); + + else if ( name == "debug" ) + SetDebug( GetImpl()->ToBool( optionValue )); + + else if ( name == "discard_input_topology" ) + SetPreCADDiscardInput( GetImpl()->ToBool( optionValue )); + + else if ( name == "merge_edges" ) + SetPreCADMergeEdges( GetImpl()->ToBool( optionValue )); + + else if ( name == "periodic_tolerance" ) + SetPeriodicTolerance( GetImpl()->ToDbl( optionValue )); + + else if ( name == "remove_duplicate_cad_faces" ) + SetPreCADRemoveDuplicateCADFaces( GetImpl()->ToBool( optionValue )); + + else if ( name == "required_entities" ) + SetRequiredEntities( optionValue ); + + else if ( name == "sewing_tolerance" ) + SetSewingTolerance( GetImpl()->ToDbl( optionValue )); + + else if ( name == "tags" ) + SetTags( optionValue ); + + // other basic options with specific methods + + else if ( name == "correct_surface_intersections" ) + SetCorrectSurfaceIntersection( GetImpl()->ToBool( optionValue )); + + else if ( name == "optimise_tiny_edges" ) + SetOptimiseTinyEdges( GetImpl()->ToBool( optionValue )); + + else if ( name == "surface_intersections_processing_max_cost" ) + SetCorrectSurfaceIntersectionMaxCost( GetImpl()->ToDbl( optionValue )); + + else if ( name == "volume_gradation" ) + SetVolumeGradation( GetImpl()->ToDbl( optionValue )); + + else if ( name == "tiny_edge_optimisation_length" ) + SetTinyEdgeOptimisationLength( GetImpl()->ToDbl( optionValue )); + + // advanced options (for backward compatibility) + + else if ( name == "create_tag_on_collision" || + name == "tiny_edge_respect_geometry" ) + AddOption( optionName, optionValue ); + + else { + bool valueChanged; + valueChanged = ( this->GetImpl()->GetOptionValue( name ) != optionValue && + this->GetImpl()->GetOptionValue( name, &valueChanged ) != optionValue ); + if ( valueChanged ) + { + this->GetImpl()->SetOptionValue(optionName, optionValue); + SMESH::TPythonDump() << _this() << ".SetOptionValue( '" << optionName << "', '" << optionValue << "' )"; + } + } } catch (const std::invalid_argument& ex) { - SALOME::ExceptionStruct ExDescription; - ExDescription.text = ex.what(); - ExDescription.type = SALOME::BAD_PARAM; - ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetOptionValue(name,value)"; - ExDescription.lineNumber = 0; - throw SALOME::SALOME_Exception(ExDescription); + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - if (valueChanged) - SMESH::TPythonDump() << _this() << ".SetOptionValue( '" << optionName << "', '" << optionValue << "' )"; } //============================================================================= void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValue(const char* optionName, const char* optionValue) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); bool valueChanged = false; try { - valueChanged = (this->GetImpl()->GetPreCADOptionValue(optionName) != optionValue); - if (valueChanged) - this->GetImpl()->SetPreCADOptionValue(optionName, optionValue); + std::string name( optionName ); + if ( !optionValue || !optionValue[0] ) + UnsetOption( optionName ); + + else if ( name == "closed_geometry" ) + SetClosedGeometry( GetImpl()->ToBool( optionValue )); + + else if ( name == "debug" ) + SetDebug( GetImpl()->ToBool( optionValue )); + + else if ( name == "discard_input_topology" ) + SetPreCADDiscardInput( GetImpl()->ToBool( optionValue )); + + else if ( name == "merge_edges" ) + SetPreCADMergeEdges( GetImpl()->ToBool( optionValue )); + + else if ( name == "periodic_tolerance" ) + SetPeriodicTolerance( GetImpl()->ToDbl( optionValue )); + + else if ( name == "remove_duplicate_cad_faces" ) + SetPreCADRemoveDuplicateCADFaces( GetImpl()->ToBool( optionValue )); + + else if ( name == "required_entities" ) + SetRequiredEntities( optionValue ); + + else if ( name == "sewing_tolerance" ) + SetSewingTolerance( GetImpl()->ToDbl( optionValue )); + + else if ( name == "tags" ) + SetTags( optionValue ); + + // other basic options with specific methods + + else if ( name == "correct_surface_intersections" ) + SetCorrectSurfaceIntersection( GetImpl()->ToBool( optionValue )); + + else if ( name == "optimise_tiny_edges" ) + SetOptimiseTinyEdges( GetImpl()->ToBool( optionValue )); + + else if ( name == "surface_intersections_processing_max_cost" ) + SetCorrectSurfaceIntersectionMaxCost( GetImpl()->ToDbl( optionValue )); + + else if ( name == "volume_gradation" ) + SetVolumeGradation( GetImpl()->ToDbl( optionValue )); + + else if ( name == "tiny_edge_optimisation_length" ) + SetTinyEdgeOptimisationLength( GetImpl()->ToDbl( optionValue )); + + else if ( name == "process_3d_topology" ) + SetPreCADProcess3DTopology( GetImpl()->ToBool( optionValue )); + + // advanced options (for backward compatibility) + + else if ( name == "create_tag_on_collision" || + name == "tiny_edge_respect_geometry" || + name == "remove_tiny_edges" || + name == "tiny_edge_length") + AddPreCADOption( optionName, optionValue ); + + else { + valueChanged = (this->GetImpl()->GetPreCADOptionValue(optionName) != optionValue); + if (valueChanged) + this->GetImpl()->SetPreCADOptionValue(optionName, optionValue); + } } catch (const std::invalid_argument& ex) { - SALOME::ExceptionStruct ExDescription; - ExDescription.text = ex.what(); - ExDescription.type = SALOME::BAD_PARAM; - ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetPreCADOptionValue(name,value)"; - ExDescription.lineNumber = 0; - throw SALOME::SALOME_Exception(ExDescription); + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } @@ -752,14 +1414,10 @@ void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValue(const char* optionName, con char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName) throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); try { - return CORBA::string_dup(this->GetImpl()->GetOptionValue(optionName).c_str()); + bool isDefault; + return CORBA::string_dup(this->GetImpl()->GetOptionValue(optionName,&isDefault).c_str()); } catch (const std::invalid_argument& ex) { - SALOME::ExceptionStruct ExDescription; - ExDescription.text = ex.what(); - ExDescription.type = SALOME::BAD_PARAM; - ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetOptionValue(name)"; - ExDescription.lineNumber = 0; - throw SALOME::SALOME_Exception(ExDescription); + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } @@ -771,14 +1429,10 @@ char* BLSURFPlugin_Hypothesis_i::GetOptionValue(const char* optionName) throw (S char* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValue(const char* optionName) throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); try { - return CORBA::string_dup(this->GetImpl()->GetPreCADOptionValue(optionName).c_str()); + bool isDefault; + return CORBA::string_dup(this->GetImpl()->GetPreCADOptionValue(optionName,&isDefault).c_str()); } catch (const std::invalid_argument& ex) { - SALOME::ExceptionStruct ExDescription; - ExDescription.text = ex.what(); - ExDescription.type = SALOME::BAD_PARAM; - ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::GetPreCADOptionValue(name)"; - ExDescription.lineNumber = 0; - throw SALOME::SALOME_Exception(ExDescription); + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } @@ -789,16 +1443,22 @@ char* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValue(const char* optionName) th void BLSURFPlugin_Hypothesis_i::UnsetOption(const char* optionName) { ASSERT(myBaseImpl); - this->GetImpl()->ClearOption(optionName); - SMESH::TPythonDump() << _this() << ".UnsetOption( '" << optionName << "' )"; + if ( !GetImpl()->GetOptionValue( optionName ).empty() ) + { + this->GetImpl()->ClearOption(optionName); + SMESH::TPythonDump() << _this() << ".UnsetOption( '" << optionName << "' )"; + } } //============================================================================= void BLSURFPlugin_Hypothesis_i::UnsetPreCADOption(const char* optionName) { ASSERT(myBaseImpl); - this->GetImpl()->ClearPreCADOption(optionName); - SMESH::TPythonDump() << _this() << ".UnsetPreCADOption( '" << optionName << "' )"; + if ( !GetImpl()->GetPreCADOptionValue( optionName ).empty() ) + { + this->GetImpl()->ClearPreCADOption(optionName); + SMESH::TPythonDump() << _this() << ".UnsetPreCADOption( '" << optionName << "' )"; + } } //============================================================================= @@ -807,88 +1467,235 @@ BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetOptionValues() { ASSERT(myBaseImpl); BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array(); - const ::BLSURFPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetOptionValues(); - result->length(opts.size()); + const ::BLSURFPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetOptionValues(); + result->length(opts.size()); + int i=0; + + bool isDefault; + ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = opts.begin(); + for (; opIt != opts.end(); ++opIt, ++i) { + string name_value_type = opIt->first; + if (!opIt->second.empty()) { + name_value_type += ":"; + name_value_type += GetImpl()->GetOptionValue( opIt->first, &isDefault ); + name_value_type += isDefault ? ":0" : ":1"; + } + result[i] = CORBA::string_dup(name_value_type.c_str()); + } + + return result._retn(); +} + +//============================================================================= + +BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValues() { + ASSERT(myBaseImpl); + BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array(); + + const ::BLSURFPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetPreCADOptionValues(); + result->length(opts.size()); + int i=0; + + bool isDefault; + ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = opts.begin(); + for (; opIt != opts.end(); ++opIt, ++i) { + string name_value_type = opIt->first; + if (!opIt->second.empty()) { + name_value_type += ":"; + name_value_type += GetImpl()->GetPreCADOptionValue( opIt->first, &isDefault ); + name_value_type += isDefault ? ":0" : ":1"; + } + result[i] = CORBA::string_dup(name_value_type.c_str()); + } + return result._retn(); +} + +//============================================================================= + +BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetAdvancedOptionValues() +{ + BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array(); + + const ::BLSURFPlugin_Hypothesis::TOptionValues & custom_opts = this->GetImpl()->GetCustomOptionValues(); + result->length(custom_opts.size()); + int i=0; + + ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = custom_opts.begin(); + for (; opIt != custom_opts.end(); ++opIt, ++i) { + string name_value_type = opIt->first; + if (!opIt->second.empty()) { + name_value_type += ":"; + name_value_type += opIt->second; + name_value_type += ":1"; // user defined + } + result[i] = CORBA::string_dup(name_value_type.c_str()); + } + return result._retn(); +} + +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array& options) + throw (SALOME::SALOME_Exception) { + ASSERT(myBaseImpl); + for (CORBA::ULong i = 0; i < options.length(); ++i) { + string name_value_type = options[i].in(); + if(name_value_type.empty()) + continue; + size_t colonPos = name_value_type.find(':'); + string name, value; + if (colonPos == string::npos) // ':' not found + name = name_value_type; + else { + name = name_value_type.substr(0, colonPos); + if (colonPos < name_value_type.size() - 1 && name_value_type[colonPos] != ' ') { + string value_type = name_value_type.substr(colonPos + 1); + colonPos = value_type.find(':'); + value = value_type.substr(0, colonPos); + if (colonPos < value_type.size() - 1 && value_type[colonPos] != ' ') + if ( value_type.substr(colonPos + 1) == "0" ) // is default + value.clear(); + } + } + SetOptionValue(name.c_str(), value.c_str()); + } +} + +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValues(const BLSURFPlugin::string_array& options) + throw (SALOME::SALOME_Exception) { + ASSERT(myBaseImpl); + for ( CORBA::ULong i = 0; i < options.length(); ++i) { + string name_value_type = options[i].in(); + if(name_value_type.empty()) + continue; + size_t colonPos = name_value_type.find(':'); + string name, value; + if (colonPos == string::npos) // ':' not found + name = name_value_type; + else { + name = name_value_type.substr(0, colonPos); + if (colonPos < name_value_type.size() - 1 && name_value_type[colonPos] != ' ') { + string value_type = name_value_type.substr(colonPos + 1); + colonPos = value_type.find(':'); + value = value_type.substr(0, colonPos); + if (colonPos < value_type.size() - 1 && value_type[colonPos] != ' ') + if ( value_type.substr(colonPos + 1) == "0" ) // is default + value.clear(); + } + } + SetPreCADOptionValue(name.c_str(), value.c_str()); + } +} + +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetAdvancedOptionValues(const BLSURFPlugin::string_array& options) +{ + SMESH::TPythonDump dump; + + string optionsAndValues; + for ( CORBA::ULong i = 0; i < options.length(); ++i) { + string name_value_type = options[i].in(); + if(name_value_type.empty()) + continue; + size_t colonPos = name_value_type.find(':'); + string name, value; + if (colonPos == string::npos) // ':' not found + name = name_value_type; + else { + name = name_value_type.substr(0, colonPos); + if (colonPos < name_value_type.size() - 1 && name_value_type[colonPos] != ' ') { + string value_type = name_value_type.substr(colonPos + 1); + colonPos = value_type.find(':'); + value = value_type.substr(0, colonPos); + } + } + AddOption(name.c_str(), value.c_str()); + + optionsAndValues += name + " " + value + " "; + } + + if ( !optionsAndValues.empty() ) + dump << _this() << ".SetAdvancedOptions( '" << optionsAndValues.c_str() << "' )"; +} + +//============================================================================= + +void BLSURFPlugin_Hypothesis_i::SetAdvancedOption(const char* optionsAndValues) + throw (SALOME::SALOME_Exception) +{ + if ( !optionsAndValues ) return; + + SMESH::TPythonDump dump; - ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = opts.begin(); - for (int i = 0; opIt != opts.end(); ++opIt, ++i) { - string name_value = opIt->first; - if (!opIt->second.empty()) { - name_value += ":"; - name_value += opIt->second; + std::istringstream strm( optionsAndValues ); + std::istream_iterator sIt( strm ), sEnd; + while ( sIt != sEnd ) + { + std::string option = *sIt; + if ( ++sIt != sEnd ) + { + std::string value = *sIt; + ++sIt; + AddOption( option.c_str(), value.c_str() ); + } + else + { + THROW_SALOME_CORBA_EXCEPTION( "Uneven number of options and values" ,SALOME::BAD_PARAM ); } - result[i] = CORBA::string_dup(name_value.c_str()); } - return result._retn(); + dump << _this() << ".SetAdvancedOption( '" << optionsAndValues << "' )"; } //============================================================================= -BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetPreCADOptionValues() { +void BLSURFPlugin_Hypothesis_i::AddOption(const char* optionName, const char* optionValue) +{ ASSERT(myBaseImpl); - BLSURFPlugin::string_array_var result = new BLSURFPlugin::string_array(); + bool valueChanged = (this->GetImpl()->GetOption(optionName) != optionValue); + if (valueChanged) { + this->GetImpl()->AddOption(optionName, optionValue); + SMESH::TPythonDump() << _this() << ".AddOption( '" << optionName << "', '" << optionValue << "' )"; + } +} - const ::BLSURFPlugin_Hypothesis::TOptionValues & opts = this->GetImpl()->GetPreCADOptionValues(); - result->length(opts.size()); +//============================================================================= - ::BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt = opts.begin(); - for (int i = 0; opIt != opts.end(); ++opIt, ++i) { - string name_value = opIt->first; - if (!opIt->second.empty()) { - name_value += ":"; - name_value += opIt->second; - } - result[i] = CORBA::string_dup(name_value.c_str()); +void BLSURFPlugin_Hypothesis_i::AddPreCADOption(const char* optionName, const char* optionValue) +{ + ASSERT(myBaseImpl); + bool valueChanged = (this->GetImpl()->GetPreCADOption(optionName) != optionValue); + if (valueChanged) { + this->GetImpl()->AddPreCADOption(optionName, optionValue); + SMESH::TPythonDump() << _this() << ".AddPreCADOption( '" << optionName << "', '" << optionValue << "' )"; } - return result._retn(); } //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetOptionValues(const BLSURFPlugin::string_array& options) - throw (SALOME::SALOME_Exception) { +char* BLSURFPlugin_Hypothesis_i::GetOption(const char* optionName) +{ ASSERT(myBaseImpl); - for (int i = 0; i < options.length(); ++i) { - string name_value = options[i].in(); - int colonPos = name_value.find(':'); - string name, value; - if (colonPos == string::npos) // ':' not found - name = name_value; - else { - name = name_value.substr(0, colonPos); - if (colonPos < name_value.size() - 1 && name_value[colonPos] != ' ') - value = name_value.substr(colonPos + 1); - } - SetOptionValue(name.c_str(), value.c_str()); - } + return CORBA::string_dup(this->GetImpl()->GetOption(optionName).c_str()); } //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetPreCADOptionValues(const BLSURFPlugin::string_array& options) - throw (SALOME::SALOME_Exception) { +char* BLSURFPlugin_Hypothesis_i::GetPreCADOption(const char* optionName) +{ ASSERT(myBaseImpl); - for (int i = 0; i < options.length(); ++i) { - string name_value = options[i].in(); - int colonPos = name_value.find(':'); - string name, value; - if (colonPos == string::npos) // ':' not found - name = name_value; - else { - name = name_value.substr(0, colonPos); - if (colonPos < name_value.size() - 1 && name_value[colonPos] != ' ') - value = name_value.substr(colonPos + 1); - } - SetPreCADOptionValue(name.c_str(), value.c_str()); - } + return CORBA::string_dup(this->GetImpl()->GetPreCADOption(optionName).c_str()); } //============================================================================= void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* sizeMap) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); - MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry); + if ( !entry || !entry[0] ) + THROW_SALOME_CORBA_EXCEPTION( "SetSizeMapEntry(): empty geom entry", SALOME::BAD_PARAM ); bool valueChanged = false; try { valueChanged = (this->GetImpl()->GetSizeMapEntry(entry) != sizeMap); @@ -904,7 +1711,6 @@ void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* s } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - MESSAGE("ENGINE : SETSIZEMAP END ENTRY : " << entry); if (valueChanged) SMESH::TPythonDump() << _this() << ".SetSizeMap(" << entry << ", '" << sizeMap << "' )"; } @@ -912,15 +1718,15 @@ void BLSURFPlugin_Hypothesis_i::SetSizeMapEntry(const char* entry, const char* s //============================================================================= void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM::shape_type shapeType, CORBA::Double sizeMap) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); - MESSAGE("ENGINE : SETSIZEMAP START ENTRY : " << entry); bool valueChanged = false; std::ostringstream sizeMapFunction; switch (shapeType) { - case GEOM::FACE: sizeMapFunction << "def f(u,v): return " << sizeMap ; break; - case GEOM::EDGE: sizeMapFunction << "def f(t): return " << sizeMap ; break; - case GEOM::VERTEX: sizeMapFunction << "def f(): return " << sizeMap ; break; + case GEOM::FACE: sizeMapFunction << "def f(u,v): return " << sizeMap ; break; + case GEOM::EDGE: sizeMapFunction << "def f(t): return " << sizeMap ; break; + case GEOM::VERTEX: sizeMapFunction << "def f(): return " << sizeMap ; break; + default:; } try { valueChanged = (this->GetImpl()->GetSizeMapEntry(entry) != sizeMapFunction.str()); @@ -936,7 +1742,6 @@ void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM: } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - MESSAGE("ENGINE : SETSIZEMAP END ENTRY : " << entry); if (valueChanged) SMESH::TPythonDump() << _this() << ".SetConstantSizeMap(" << entry << ", '" << sizeMap << "' )"; } @@ -944,9 +1749,8 @@ void BLSURFPlugin_Hypothesis_i::SetConstantSizeMapEntry(const char* entry, GEOM: //============================================================================= void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char* attractor) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); - MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry); bool valueChanged = false; try { valueChanged = ( this->GetImpl()->GetAttractorEntry(entry) != attractor ); @@ -966,7 +1770,6 @@ void BLSURFPlugin_Hypothesis_i::SetAttractorEntry(const char* entry, const char* } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - MESSAGE("ENGINE : SETATTRACTOR END ENTRY : " << entry); if (valueChanged) SMESH::TPythonDump() << _this() << ".SetAttractor(" << entry << ", '" << attractor << "' )"; } @@ -977,8 +1780,7 @@ void BLSURFPlugin_Hypothesis_i::SetClassAttractorEntry(const char* entry, const throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); - MESSAGE("ENGINE : SETATTRACTOR START ENTRY : " << entry); - bool valueChanged = false; + //bool valueChanged = false; try { this->GetImpl()->SetClassAttractorEntry(entry, att_entry, StartSize, EndSize, ActionRadius, ConstantRadius); } @@ -992,10 +1794,9 @@ void BLSURFPlugin_Hypothesis_i::SetClassAttractorEntry(const char* entry, const } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - MESSAGE("ENGINE : SETATTRACTOR END ENTRY : " << entry); //if ( valueChanged ) - SMESH::TPythonDump() << _this() << ".SetAttractorGeom( '" - << entry << "', '" << att_entry << "', "<second->Empty() ) { attEntry = atIt->second->GetAttractorEntry(); - MESSAGE("GetAttractorParams : attEntry ="< params = atIt->second->GetParameters(); startSize = params[0]; endSize = params[1]; @@ -1141,8 +1941,6 @@ BLSURFPlugin::TAttParamsMap* BLSURFPlugin_Hypothesis_i::GetAttractorParams() result[i].endSize = endSize; result[i].infDist = infDist; result[i].constDist = constDist; - MESSAGE("GetAttractorParams : result[i].attEntry ="<GetName()); - MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")"); SetSizeMapEntry(entry.c_str(), sizeMap); } @@ -1193,8 +1991,6 @@ void BLSURFPlugin_Hypothesis_i::SetConstantSizeMap(const GEOM::GEOM_Object_ptr G GEOM::shape_type shapeType = GeomObj->GetShapeType(); if (shapeType == GEOM::COMPOUND) shapeType = GeomObj->GetMaxShapeType(); - MESSAGE("IDL : GetName : " << GeomObj->GetName()); - MESSAGE("IDL : SETSIZEMAP ( "<< entry << " , " << sizeMap << ")"); SetConstantSizeMapEntry(entry.c_str(), shapeType, sizeMap); } @@ -1203,8 +1999,6 @@ void BLSURFPlugin_Hypothesis_i::UnsetSizeMap(const GEOM::GEOM_Object_ptr GeomObj ASSERT(myBaseImpl); string entry; entry = GeomObj->GetStudyEntry(); - MESSAGE("IDL : GetName : " << GeomObj->GetName()); - MESSAGE("IDL : UNSETSIZEMAP ( "<< entry << ")"); UnsetEntry(entry.c_str()); SMESH::TPythonDump() << _this() << ".UnsetSizeMap( " << entry.c_str() << " )"; } @@ -1213,8 +2007,6 @@ void BLSURFPlugin_Hypothesis_i::SetAttractor(GEOM::GEOM_Object_ptr GeomObj, cons ASSERT(myBaseImpl); string entry; entry = GeomObj->GetStudyEntry(); - MESSAGE("IDL : GetName : " << GeomObj->GetName()); - MESSAGE("IDL : SETATTRACTOR ( "<< entry << " , " << attractor << ")"); SetAttractorEntry(entry.c_str(), attractor); } @@ -1222,8 +2014,6 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractor(GEOM::GEOM_Object_ptr GeomObj) { ASSERT(myBaseImpl); string entry; entry = GeomObj->GetStudyEntry(); - MESSAGE("IDL : GetName : " << GeomObj->GetName()); - MESSAGE("IDL : UNSETATTRACTOR ( "<< entry << ")"); UnsetEntry(entry.c_str()); SMESH::TPythonDump() << _this() << ".UnsetAttractor( " << entry.c_str() << " )"; } @@ -1269,8 +2059,6 @@ void BLSURFPlugin_Hypothesis_i::SetAttractorGeom(GEOM::GEOM_Object_ptr theFace, TopoDS_Face FaceShape = TopoDS::Face(SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theFace )); TopoDS_Shape AttractorShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theAttractor ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : SETATTRACTOR () ");//<< entry << " , " << att_entry << ")"); SetClassAttractorEntry( theFaceEntry.c_str(), theAttEntry.c_str(), StartSize, EndSize, ActionRadius, ConstantRadius); } @@ -1296,8 +2084,6 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractorGeom(GEOM::GEOM_Object_ptr theFace !theAttrEntry.in() || !theAttrEntry.in()[0] ) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : UNSETATTRACTOR ( "<< theFaceEntry << ")"); GetImpl()->ClearEntry( theFaceEntry.in(), theAttrEntry.in() ); SMESH::TPythonDump() << _this() << ".UnsetAttractorGeom( " << theFace << ", " << theAttractor << " )"; @@ -1313,30 +2099,30 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractorEntry(const char* faceEntry, /* - void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap) - {} + void BLSURFPlugin_Hypothesis_i::SetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj, const char* sizeMap) + {} - void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj) - {} + void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMap(GEOM::GEOM_Object_ptr GeomObj) + {} - void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception) - {} + void BLSURFPlugin_Hypothesis_i::SetCustomSizeMapEntry(const char* entry,const char* sizeMap ) throw (SALOME::SALOME_Exception) + {} - char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception) - {} + char* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntry(const char* entry) throw (SALOME::SALOME_Exception) + {} - void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry) - { - ASSERT(myBaseImpl); - this->GetImpl()->UnsetCustomSizeMap(entry); - SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )"; - } + void BLSURFPlugin_Hypothesis_i::UnsetCustomSizeMapEntry(const char* entry) + { + ASSERT(myBaseImpl); + this->GetImpl()->UnsetCustomSizeMap(entry); + SMESH::TPythonDump() << _this() << ".UnsetCustomSizeMap( " << entry << " )"; + } - BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries() - {} + BLSURFPlugin::string_array* BLSURFPlugin_Hypothesis_i::GetCustomSizeMapEntries() + {} - */ +*/ // /////////////////////// // // ENFORCED VERTICES // @@ -1349,28 +2135,24 @@ void BLSURFPlugin_Hypothesis_i::UnsetAttractorEntry(const char* faceEntry, * */ BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByFace() { - MESSAGE("IDL: GetAllEnforcedVerticesByFace()"); ASSERT(myBaseImpl); BLSURFPlugin::TFaceEntryEnfVertexListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexListMap(); const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap faceEntryEnfVertexListMap = - this->GetImpl()->_GetAllEnforcedVerticesByFace(); + this->GetImpl()->_GetAllEnforcedVerticesByFace(); resultMap->length(faceEntryEnfVertexListMap.size()); - MESSAGE("Face entry to Enforced Vertex map size is " << resultMap->length()); ::BLSURFPlugin_Hypothesis::TEnfVertexList _enfVertexList; ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexListMap::const_iterator it_entry = faceEntryEnfVertexListMap.begin(); for (int i = 0; it_entry != faceEntryEnfVertexListMap.end(); ++it_entry, ++i) { BLSURFPlugin::TFaceEntryEnfVertexListMapElement_var mapElement = - new BLSURFPlugin::TFaceEntryEnfVertexListMapElement(); + new BLSURFPlugin::TFaceEntryEnfVertexListMapElement(); mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str()); - MESSAGE("Face Entry: " << mapElement->faceEntry); _enfVertexList = it_entry->second; BLSURFPlugin::TEnfVertexList_var enfVertexList = new BLSURFPlugin::TEnfVertexList(); enfVertexList->length(_enfVertexList.size()); - MESSAGE("Number of enf vertex: " << enfVertexList->length()); ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator it_enfVertex = _enfVertexList.begin(); ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex; @@ -1388,7 +2170,7 @@ BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfor // Coords BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords(); coords->length(currentEnfVertex->coords.size()); - for (int i=0;ilength();i++) + for (CORBA::ULong i=0;ilength();i++) coords[i] = currentEnfVertex->coords[i]; enfVertex->coords = coords; @@ -1407,10 +2189,9 @@ BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfor msg << "Enforced vertex: \n" << "Name: " << enfVertex->name << "\n"; if (coords->length()) - msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; + msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; msg << "Geom entry: " << enfVertex->geomEntry << "\n" << "Group Name: " << enfVertex->grpName; - MESSAGE(msg.str()); enfVertexList[j] = enfVertex; } @@ -1428,17 +2209,14 @@ BLSURFPlugin::TFaceEntryEnfVertexListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfor * */ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices() { - MESSAGE("IDL: GetAllEnforcedVertices()"); ASSERT(myBaseImpl); BLSURFPlugin::TEnfVertexList_var resultMap = new BLSURFPlugin::TEnfVertexList(); const ::BLSURFPlugin_Hypothesis::TEnfVertexList enfVertexList = this->GetImpl()->_GetAllEnforcedVertices(); resultMap->length(enfVertexList.size()); - MESSAGE("Enforced Vertex map size is " << resultMap->length()); ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = enfVertexList.begin(); ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex; for (int i = 0; evlIt != enfVertexList.end(); ++evlIt, ++i) { - MESSAGE("Enforced Vertex #" << i); currentEnfVertex = (*evlIt); BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex(); // Name @@ -1448,7 +2226,7 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices( // Coords BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords(); coords->length(currentEnfVertex->coords.size()); - for (int ind = 0; ind < coords->length(); ind++) + for (CORBA::ULong ind = 0; ind < coords->length(); ind++) coords[ind] = currentEnfVertex->coords[ind]; enfVertex->coords = coords; // Group name @@ -1465,10 +2243,9 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices( msg << "Enforced vertex: \n" << "Name: " << enfVertex->name << "\n"; if (coords->length()) - msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; + msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; msg << "Geom entry: " << enfVertex->geomEntry << "\n" << "Group Name: " << enfVertex->grpName; - MESSAGE(msg.str()); resultMap[i] = enfVertex; } @@ -1483,35 +2260,30 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVertices( * */ BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsByFace() { - MESSAGE("IDL: GetAllCoordsByFace()"); ASSERT(myBaseImpl); BLSURFPlugin::TFaceEntryCoordsListMap_var resultMap = new BLSURFPlugin::TFaceEntryCoordsListMap(); const ::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap entryCoordsListMap = this->GetImpl()->_GetAllCoordsByFace(); resultMap->length(entryCoordsListMap.size()); - MESSAGE("Enforced Vertex map size is " << resultMap->length()); ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList _coordsList; ::BLSURFPlugin_Hypothesis::TFaceEntryCoordsListMap::const_iterator it_entry = entryCoordsListMap.begin(); for (int i = 0; it_entry != entryCoordsListMap.end(); ++it_entry, ++i) { BLSURFPlugin::TFaceEntryCoordsListMapElement_var mapElement = new BLSURFPlugin::TFaceEntryCoordsListMapElement(); mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str()); - MESSAGE("Face Entry: " << mapElement->faceEntry); _coordsList = it_entry->second; BLSURFPlugin::TEnfVertexCoordsList_var coordsList = new BLSURFPlugin::TEnfVertexCoordsList(); coordsList->length(_coordsList.size()); - MESSAGE("Number of coords: " << coordsList->length()); ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList::const_iterator it_coords = _coordsList.begin(); for (int j = 0; it_coords != _coordsList.end(); ++it_coords, ++j) { BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords(); coords->length((*it_coords).size()); - for (int i=0;ilength();i++) + for (CORBA::ULong i=0;ilength();i++) coords[i] = (*it_coords)[i]; coordsList[j] = coords; - MESSAGE("Coords #" << j << ": " << coords[0] << ", " << coords[1] << ", " << coords[2]); } mapElement->coordsList = coordsList; @@ -1526,27 +2298,23 @@ BLSURFPlugin::TFaceEntryCoordsListMap* BLSURFPlugin_Hypothesis_i::GetAllCoordsBy * They are the coords of the "manual" enforced vertices. */ BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByCoords() { - MESSAGE("IDL: GetAllEnforcedVerticesByCoords()"); ASSERT(myBaseImpl); BLSURFPlugin::TCoordsEnfVertexMap_var resultMap = new BLSURFPlugin::TCoordsEnfVertexMap(); const ::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap coordsEnfVertexMap = - this->GetImpl()->_GetAllEnforcedVerticesByCoords(); + this->GetImpl()->_GetAllEnforcedVerticesByCoords(); resultMap->length(coordsEnfVertexMap.size()); - MESSAGE("Enforced Vertex map size is " << resultMap->length()); ::BLSURFPlugin_Hypothesis::TCoordsEnfVertexMap::const_iterator it_coords = coordsEnfVertexMap.begin(); ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex; for (int i = 0; it_coords != coordsEnfVertexMap.end(); ++it_coords, ++i) { - MESSAGE("Enforced Vertex #" << i); currentEnfVertex = (it_coords->second); BLSURFPlugin::TCoordsEnfVertexElement_var mapElement = new BLSURFPlugin::TCoordsEnfVertexElement(); BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords(); coords->length(it_coords->first.size()); - for (int ind=0;indlength();ind++) + for (CORBA::ULong ind=0;indlength();ind++) coords[ind] = it_coords->first[ind]; mapElement->coords = coords; - MESSAGE("Coords: " << mapElement->coords[0] << ", " << mapElement->coords[1] << ", " << mapElement->coords[2]); BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex(); // Name @@ -1556,7 +2324,7 @@ BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVert // Coords BLSURFPlugin::TEnfVertexCoords_var coords2 = new BLSURFPlugin::TEnfVertexCoords(); coords2->length(currentEnfVertex->coords.size()); - for (int ind=0;indlength();ind++) + for (CORBA::ULong ind=0;indlength();ind++) coords2[ind] = currentEnfVertex->coords[ind]; enfVertex->coords = coords2; // Group name @@ -1574,10 +2342,9 @@ BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVert msg << "Enforced vertex: \n" << "Name: " << enfVertex->name << "\n"; if (coords->length()) - msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; + msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; msg << "Geom entry: " << enfVertex->geomEntry << "\n" << "Group Name: " << enfVertex->grpName; - MESSAGE(msg.str()); resultMap[i] = mapElement; } @@ -1591,34 +2358,29 @@ BLSURFPlugin::TCoordsEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVert * */ BLSURFPlugin::TFaceEntryEnfVertexEntryListMap* BLSURFPlugin_Hypothesis_i::GetAllEnfVertexEntriesByFace() { - MESSAGE("IDL: GetAllEnfVertexEntriesByFace()"); ASSERT(myBaseImpl); BLSURFPlugin::TFaceEntryEnfVertexEntryListMap_var resultMap = new BLSURFPlugin::TFaceEntryEnfVertexEntryListMap(); const ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap entryEnfVertexEntryListMap = - this->GetImpl()->_GetAllEnfVertexEntriesByFace(); + this->GetImpl()->_GetAllEnfVertexEntriesByFace(); resultMap->length(entryEnfVertexEntryListMap.size()); - MESSAGE("Enforced Vertex map size is " << resultMap->length()); ::BLSURFPlugin_Hypothesis::TEntryList _enfVertexEntryList; ::BLSURFPlugin_Hypothesis::TFaceEntryEnfVertexEntryListMap::const_iterator it_entry = entryEnfVertexEntryListMap.begin(); for (int i = 0; it_entry != entryEnfVertexEntryListMap.end(); ++it_entry, ++i) { BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement_var mapElement = - new BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement(); + new BLSURFPlugin::TFaceEntryEnfVertexEntryListMapElement(); mapElement->faceEntry = CORBA::string_dup(it_entry->first.c_str()); - MESSAGE("Face Entry: " << mapElement->faceEntry); _enfVertexEntryList = it_entry->second; BLSURFPlugin::TEntryList_var enfVertexEntryList = new BLSURFPlugin::TEntryList(); enfVertexEntryList->length(_enfVertexEntryList.size()); - MESSAGE("Number of enf vertex entries: " << enfVertexEntryList->length()); ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it_enfVertexEntry = _enfVertexEntryList.begin(); for (int j = 0; it_enfVertexEntry != _enfVertexEntryList.end(); ++it_enfVertexEntry, ++j) { enfVertexEntryList[j] = CORBA::string_dup((*it_enfVertexEntry).c_str()); - MESSAGE("Enf Vertex Entry #" << j << ": " << enfVertexEntryList[j]); } mapElement->enfVertexEntryList = enfVertexEntryList; @@ -1633,23 +2395,19 @@ BLSURFPlugin::TFaceEntryEnfVertexEntryListMap* BLSURFPlugin_Hypothesis_i::GetAll * They are the geom entries of the enforced vertices defined with geom shape (vertex, compound, group). */ BLSURFPlugin::TEnfVertexEntryEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnforcedVerticesByEnfVertexEntry() { - MESSAGE("IDL: GetAllEnforcedVerticesByEnfVertexEntry()"); ASSERT(myBaseImpl); BLSURFPlugin::TEnfVertexEntryEnfVertexMap_var resultMap = new BLSURFPlugin::TEnfVertexEntryEnfVertexMap(); const ::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap enfVertexEntryEnfVertexMap = - this->GetImpl()->_GetAllEnforcedVerticesByEnfVertexEntry(); + this->GetImpl()->_GetAllEnforcedVerticesByEnfVertexEntry(); resultMap->length(enfVertexEntryEnfVertexMap.size()); - MESSAGE("Enforced Vertex map size is " << resultMap->length()); ::BLSURFPlugin_Hypothesis::TEnfVertexEntryEnfVertexMap::const_iterator it_enfVertexEntry = enfVertexEntryEnfVertexMap.begin(); ::BLSURFPlugin_Hypothesis::TEnfVertex *currentEnfVertex; for (int i = 0; it_enfVertexEntry != enfVertexEntryEnfVertexMap.end(); ++it_enfVertexEntry, ++i) { - MESSAGE("Enforced Vertex #" << i); currentEnfVertex = it_enfVertexEntry->second; BLSURFPlugin::TEnfVertexEntryEnfVertexElement_var mapElement = new BLSURFPlugin::TEnfVertexEntryEnfVertexElement(); mapElement->enfVertexEntry = CORBA::string_dup(it_enfVertexEntry->first.c_str());; - MESSAGE("Enf Vertex Entry #" << i << ": " << mapElement->enfVertexEntry); BLSURFPlugin::TEnfVertex_var enfVertex = new BLSURFPlugin::TEnfVertex(); // Name @@ -1659,7 +2417,7 @@ BLSURFPlugin::TEnfVertexEntryEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnfo // Coords BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords(); coords->length(currentEnfVertex->coords.size()); - for (int ind=0;indlength();ind++) + for (CORBA::ULong ind=0;indlength();ind++) coords[ind] = currentEnfVertex->coords[ind]; enfVertex->coords = coords; // Group name @@ -1676,10 +2434,9 @@ BLSURFPlugin::TEnfVertexEntryEnfVertexMap* BLSURFPlugin_Hypothesis_i::GetAllEnfo msg << "Enforced vertex: \n" << "Name: " << enfVertex->name << "\n"; if (coords->length()) - msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; + msg << "Coords: " << enfVertex->coords[0] << ", " << enfVertex->coords[1] << ", " << enfVertex->coords[2] << "\n"; msg << "Geom entry: " << enfVertex->geomEntry << "\n" << "Group Name: " << enfVertex->grpName; - MESSAGE(msg.str()); mapElement->enfVertex = enfVertex; resultMap[i] = mapElement; @@ -1697,14 +2454,13 @@ void BLSURFPlugin_Hypothesis_i::ClearAllEnforcedVertices() { } /*! - * Set/get/unset an enforced vertex on face + * Set/get/unset an enforced vertex on face - OBSOLETE */ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, - CORBA::Double z) throw (SALOME::SALOME_Exception) { + CORBA::Double z) throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } @@ -1725,8 +2481,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, } if (theFaceEntry.empty()) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : SetEnforcedVertex( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ")"); try { return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z); } catch (SALOME_Exception& ex) { @@ -1738,11 +2492,10 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, * Set/get/unset an enforced vertex with name on face */ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, - CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) { + CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } @@ -1764,8 +2517,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr the if (theFaceEntry.empty()) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : SetEnforcedVertexNamed( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theVertexName << ")"); try { return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName); } catch (SALOME_Exception& ex) { @@ -1777,16 +2528,14 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamed(GEOM::GEOM_Object_ptr the * Set/get/unset an enforced vertex with geom object on face */ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theVertex shape type is not VERTEX or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM); } @@ -1833,9 +2582,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theF THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); string theVertexName = theVertex->GetName(); - MESSAGE("IDL : theFace->GetName : " << theFace->GetName()); - MESSAGE("IDL : theVertex->GetName : " << theVertexName); - MESSAGE("IDL : SetEnforcedVertexGeom( "<< theFaceEntry << ", " << theVertexEntry<< ")"); try { return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str()); } catch (SALOME_Exception& ex) { @@ -1847,12 +2593,11 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theF * Set an enforced vertex with group name on face */ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName) - throw (SALOME::SALOME_Exception) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } @@ -1873,8 +2618,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr } if (theFaceEntry.empty()) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : SetEnforcedVertexWithGroup( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theGroupName << ")"); try { return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, "", "", theGroupName); } catch (SALOME_Exception& ex) { @@ -1887,12 +2630,11 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr */ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName, const char* theGroupName) - throw (SALOME::SALOME_Exception) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } @@ -1913,8 +2655,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Objec } if (theFaceEntry.empty()) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : SetEnforcedVertexNamedWithGroup( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ", " << theVertexName << ", " << theGroupName << ")"); try { return SetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z, theVertexName, "", theGroupName); } catch (SALOME_Exception& ex) { @@ -1926,17 +2666,15 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(GEOM::GEOM_Objec * Set an enforced vertex with geom entry and group name on face */ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex, const char* theGroupName) - throw (SALOME::SALOME_Exception) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theVertex shape type is not VERTEX or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM); } @@ -1974,9 +2712,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); string theVertexName = theVertex->GetName(); - MESSAGE("IDL : theFace->GetName : " << theFace->GetName()); - MESSAGE("IDL : theVertex->GetName : " << theVertexName); - MESSAGE("IDL : SetEnforcedVertexGeomWithGroup( "<< theFaceEntry << ", " << theVertexEntry<< ", " << theGroupName<< ")"); try { return SetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName); } catch (SALOME_Exception& ex) { @@ -1993,7 +2728,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object // ASSERT(myBaseImpl); // if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { -// MESSAGE("theFace shape type is not FACE or COMPOUND"); // THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); // } @@ -2015,8 +2749,6 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object // if (theFaceEntry.empty()) // THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); -// MESSAGE("IDL : GetName : " << theFace->GetName()); -// MESSAGE("IDL : GetInternalEnforcedVertexEntry ( "<< theFaceEntry << ")"); // try { // return GetInternalEnforcedVertexEntry(theFaceEntry.c_str()); // } catch (SALOME_Exception& ex) { @@ -2028,11 +2760,10 @@ bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object * Get the list of all enforced vertices */ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } @@ -2054,8 +2785,6 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEO if (theFaceEntry.empty()) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : GetEnforcedVerticesEntry ( "<< theFaceEntry << ")"); try { return GetEnforcedVerticesEntry(theFaceEntry.c_str()); } catch (SALOME_Exception& ex) { @@ -2064,11 +2793,10 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVertices(GEO } bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Double x, CORBA::Double y, - CORBA::Double z) throw (SALOME::SALOME_Exception) { + CORBA::Double z) throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } @@ -2089,8 +2817,6 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFac } if (theFaceEntry.empty()) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : UnsetEnforcedVertex ( "<< theFaceEntry << ", " << x << ", " << y << ", " << z << ")"); try { return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), x, y, z); @@ -2100,15 +2826,13 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertex(GEOM::GEOM_Object_ptr theFac } bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theFace, GEOM::GEOM_Object_ptr theVertex) - throw (SALOME::SALOME_Exception) { + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); } if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theVertex shape type is not VERTEX or COMPOUND"); THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM); } @@ -2121,26 +2845,231 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr th // x = y = z = 0.; // measureOp->PointCoordinates(theVertex, x, y, z); - std::string theFaceEntry = theFace->GetStudyEntry(); + std::string theFaceEntry = theFace->GetStudyEntry(); + std::string theVertexEntry = theVertex->GetStudyEntry(); + + GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); + SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); + string aName; + + if (theFaceEntry.empty()) { + if (theFace->GetShapeType() == GEOM::FACE) + aName = "Face_"; + if (theFace->GetShapeType() == GEOM::COMPOUND) + aName = "Compound_"; + aName += theFace->GetEntry(); + SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str()); + if (!theSFace->_is_nil()) + theFaceEntry = theSFace->GetID(); + } + if (theFaceEntry.empty()) + THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); + + if (theVertexEntry.empty()) { + if (theVertex->GetShapeType() == GEOM::VERTEX) + aName = "Vertex_"; + if (theVertex->GetShapeType() == GEOM::COMPOUND) + aName = "Compound_"; + aName += theVertex->GetEntry(); + SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theVertex, aName.c_str()); + if (!theSVertex->_is_nil()) + theVertexEntry = theSVertex->GetID(); + } + if (theVertexEntry.empty()) + THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); + + + try { + return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexEntry.c_str()); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception) { + ASSERT(myBaseImpl); + + if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { + THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); + } + + string theFaceEntry = theFace->GetStudyEntry(); + + if (theFaceEntry.empty()) { + GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); + SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); + string aName; + if (theFace->GetShapeType() == GEOM::FACE) + aName = "Face_"; + if (theFace->GetShapeType() == GEOM::COMPOUND) + aName = "Compound_"; + aName += theFace->GetEntry(); + SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str()); + if (!theSFace->_is_nil()) + theFaceEntry = theSFace->GetID(); + } + if (theFaceEntry.empty()) + THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); + + + try { + return UnsetEnforcedVerticesEntry(theFaceEntry.c_str()); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +/*! + * Set/get/unset an enforced vertex on face - NEW (no face) + */ +bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception) +{ + ASSERT(myBaseImpl); + + try { + return SetEnforcedVertexEntry("", x, y, z); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +/*! + * Set/get/unset an enforced vertex with name on face + */ +bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexName) throw (SALOME::SALOME_Exception) +{ + try { + return SetEnforcedVertexEntry("", x, y, z, theVertexName); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +/*! + * Set/get/unset an enforced vertex with geom object on face + */ +bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex) + throw (SALOME::SALOME_Exception) +{ + if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) { + THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM); + } + string theVertexEntry = theVertex->GetStudyEntry(); + + GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); + SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); + string aName; + + if (theVertexEntry.empty()) { + if (theVertex->GetShapeType() == GEOM::VERTEX) + aName = "Vertex_"; + if (theVertex->GetShapeType() == GEOM::COMPOUND) + aName = "Compound_"; + aName += theVertex->GetEntry(); + SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theVertex, aName.c_str()); + if (!theSVertex->_is_nil()) + theVertexEntry = theSVertex->GetID(); + } + if (theVertexEntry.empty()) + THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); + + string theVertexName = theVertex->GetName(); + try { + return SetEnforcedVertexEntry("", 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str()); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +/*! + * Set an enforced vertex with group name on face + */ +bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theGroupName) + throw (SALOME::SALOME_Exception) +{ + ASSERT(myBaseImpl); + + try { + return SetEnforcedVertexEntry("", x, y, z, "", "", theGroupName); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +/*! + * Set an enforced vertex with name and group name on face + */ +bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, + const char* theVertexName, const char* theGroupName) + throw (SALOME::SALOME_Exception) +{ + ASSERT(myBaseImpl); + + try { + return SetEnforcedVertexEntry("", x, y, z, theVertexName, "", theGroupName); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +/*! + * Set an enforced vertex with geom entry and group name on face + */ +bool BLSURFPlugin_Hypothesis_i::AddEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, const char* theGroupName) + throw (SALOME::SALOME_Exception) +{ + if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) { + THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM); + } + + string theVertexEntry = theVertex->GetStudyEntry(); + + GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); + SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); + string aName; + + if (theVertexEntry.empty()) { + if (theVertex->GetShapeType() == GEOM::VERTEX) + aName = "Vertex_"; + if (theVertex->GetShapeType() == GEOM::COMPOUND) + aName = "Compound_"; + aName += theVertex->GetEntry(); + SALOMEDS::SObject_wrap theSVertex = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theVertex, aName.c_str()); + if (!theSVertex->_is_nil()) + theVertexEntry = theSVertex->GetID(); + } + if (theVertexEntry.empty()) + THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); + + string theVertexName = theVertex->GetName(); + try { + return SetEnforcedVertexEntry("", 0, 0, 0, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception) +{ + try { + return UnsetEnforcedVertexEntry("", x, y, z); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } +} + +bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex) + throw (SALOME::SALOME_Exception) +{ + if ((theVertex->GetShapeType() != GEOM::VERTEX) && (theVertex->GetShapeType() != GEOM::COMPOUND)) { + THROW_SALOME_CORBA_EXCEPTION("theVertex shape type is not VERTEX or COMPOUND", SALOME::BAD_PARAM); + } std::string theVertexEntry = theVertex->GetStudyEntry(); GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); string aName; - if (theFaceEntry.empty()) { - if (theFace->GetShapeType() == GEOM::FACE) - aName = "Face_"; - if (theFace->GetShapeType() == GEOM::COMPOUND) - aName = "Compound_"; - aName += theFace->GetEntry(); - SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str()); - if (!theSFace->_is_nil()) - theFaceEntry = theSFace->GetID(); - } - if (theFaceEntry.empty()) - THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - if (theVertexEntry.empty()) { if (theVertex->GetShapeType() == GEOM::VERTEX) aName = "Vertex_"; @@ -2154,46 +3083,17 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexGeom(GEOM::GEOM_Object_ptr th if (theVertexEntry.empty()) THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - MESSAGE("IDL : UnsetEnforcedVertexGeom ( "<< theFaceEntry << ", " << theVertexEntry << ")"); - try { - return UnsetEnforcedVertexEntry(theFaceEntry.c_str(), 0, 0, 0, theVertexEntry.c_str()); + return UnsetEnforcedVertexEntry("", 0, 0, 0, theVertexEntry.c_str()); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } } -bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theFace) throw (SALOME::SALOME_Exception) { - ASSERT(myBaseImpl); - - if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); - THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); - } - - string theFaceEntry = theFace->GetStudyEntry(); - - if (theFaceEntry.empty()) { - GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); - SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); - string aName; - if (theFace->GetShapeType() == GEOM::FACE) - aName = "Face_"; - if (theFace->GetShapeType() == GEOM::COMPOUND) - aName = "Compound_"; - aName += theFace->GetEntry(); - SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str()); - if (!theSFace->_is_nil()) - theFaceEntry = theSFace->GetID(); - } - if (theFaceEntry.empty()) - THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : UnsetEnforcedVertices ( "<< theFaceEntry << ")"); - +bool BLSURFPlugin_Hypothesis_i::RemoveEnforcedVertices() throw (SALOME::SALOME_Exception) +{ try { - return UnsetEnforcedVerticesEntry(theFaceEntry.c_str()); + return UnsetEnforcedVerticesEntry(""); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } @@ -2202,113 +3102,89 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertices(GEOM::GEOM_Object_ptr theF /*! * Set/get/unset an enforced vertex on geom object given by entry */ -bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, - CORBA::Double z, const char* theVertexName, const char* theVertexEntry, const char* theGroupName) - throw (SALOME::SALOME_Exception) { - ASSERT(myBaseImpl); - MESSAGE("IDL : SetEnforcedVertexEntry(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" << theVertexName << "\", \"" << theVertexEntry << "\", \"" << theGroupName << "\")"); +bool BLSURFPlugin_Hypothesis_i::SetEnforcedVertexEntry(const char* theFaceEntry, + CORBA::Double x, + CORBA::Double y, + CORBA::Double z, + const char* theVertexName, + const char* theVertexEntry, + const char* theGroupName) + throw (SALOME::SALOME_Exception) +{ bool newValue = false; if (string(theVertexEntry).empty()) { try { ::BLSURFPlugin_Hypothesis::TEnfVertexCoordsList coordsList = - this->GetImpl()->GetEnfVertexCoordsList(theFaceEntry); + this->GetImpl()->GetEnfVertexCoordsList(theFaceEntry); ::BLSURFPlugin_Hypothesis::TEnfVertexCoords coords; coords.push_back(x); coords.push_back(y); coords.push_back(z); if (coordsList.find(coords) == coordsList.end()) { - MESSAGE("Coords not found: add it in coordsList"); newValue = true; } else { - MESSAGE("Coords already found, compare names"); ::BLSURFPlugin_Hypothesis::TEnfVertex *enfVertex = this->GetImpl()->GetEnfVertex(coords); if ((enfVertex->name != theVertexName) || (enfVertex->grpName != theGroupName)) { - MESSAGE("The names are different: update"); -// this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z); newValue = true; } - else { - MESSAGE("The names are identical"); - } } } catch (const std::invalid_argument& ex) { // no enforced vertex for entry - MESSAGE("Face entry not found : add it to the list"); newValue = true; } - if (newValue) - if (string(theVertexName).empty()) + if (newValue) { + if (string(theVertexName).empty()) { if (string(theGroupName).empty()) - SMESH::TPythonDump() << _this() << ".SetEnforcedVertex(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ")"; + SMESH::TPythonDump() << _this() << ".AddEnforcedVertex(" << x << ", " << y << ", " << z << ")"; else - SMESH::TPythonDump() << _this() << ".SetEnforcedVertexWithGroup(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" << theGroupName << "\")"; - else + SMESH::TPythonDump() << _this() << ".AddEnforcedVertexWithGroup(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" << theGroupName << "\")"; + } + else { if (string(theGroupName).empty()) - SMESH::TPythonDump() << _this() << ".SetEnforcedVertexNamed(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" << theVertexName << "\")"; + SMESH::TPythonDump() << _this() << ".AddEnforcedVertexNamed(" << x << ", " << y << ", " << z << ", \"" << theVertexName << "\")"; else - SMESH::TPythonDump() << _this() << ".SetEnforcedVertexNamedWithGroup(" << theFaceEntry << ", " << x << ", " << y << ", " << z << ", \"" - << theVertexName << "\", \"" << theGroupName << "\")"; + SMESH::TPythonDump() << _this() << ".AddEnforcedVertexNamedWithGroup(" << x << ", " << y << ", " << z << ", \"" + << theVertexName << "\", \"" << theGroupName << "\")"; + } + } } else { try { ::BLSURFPlugin_Hypothesis::TEntryList enfVertexEntryList = this->GetImpl()->GetEnfVertexEntryList(theFaceEntry); ::BLSURFPlugin_Hypothesis::TEntryList::const_iterator it = enfVertexEntryList.find(theVertexEntry); if ( it == enfVertexEntryList.end()) { - MESSAGE("Geom entry not found: add it in enfVertexEntryList"); newValue = true; } else { - MESSAGE("Geom entry already found, compare names"); ::BLSURFPlugin_Hypothesis::TEnfVertex *enfVertex = this->GetImpl()->GetEnfVertex((*it)); if ((enfVertex->name != theVertexName) || (enfVertex->grpName != theGroupName)) { - MESSAGE("The names are different: update"); -// this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z); newValue = true; } - else { - MESSAGE("The names are identical"); - } } } catch (const std::invalid_argument& ex) { // no enforced vertex for entry - MESSAGE("Face entry not found : add it to the list"); newValue = true; } - if (newValue) - if (string(theGroupName).empty()) - SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGeom(" << theFaceEntry << ", " << theVertexEntry << ")"; - else - SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGeomWithGroup(" << theFaceEntry << ", " << theVertexEntry << ", \"" << theGroupName << "\")"; + if (newValue) { + if (string(theGroupName).empty()) + SMESH::TPythonDump() << _this() << ".AddEnforcedVertexGeom(" << theVertexEntry << ")"; + else + SMESH::TPythonDump() << _this() << ".AddEnforcedVertexGeomWithGroup(" << theVertexEntry << ", \"" << theGroupName << "\")"; + } } if (newValue) this->GetImpl()->SetEnforcedVertex(theFaceEntry, theVertexName, theVertexEntry, theGroupName, x, y, z); - MESSAGE("IDL : SetEnforcedVertexEntry END"); return newValue; } -//Enable internal enforced vertices on specific face if requested by user -//CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexEntry(const char* theFaceEntry) -// throw (SALOME::SALOME_Exception) { -// ASSERT(myBaseImpl); -// try { -// return this->GetImpl()->GetInternalEnforcedVertex(theFaceEntry); -// } catch (const std::exception& ex) { -// std::cout << "Exception: " << ex.what() << std::endl; -// THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); -// } -//} - BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntry(const char* entry) - throw (SALOME::SALOME_Exception) { - ASSERT(myBaseImpl); - MESSAGE("ENGINE : GetEnforcedVerticesEntry START ENTRY : " << entry); - + throw (SALOME::SALOME_Exception) +{ try { BLSURFPlugin::TEnfVertexList_var vertexList = new BLSURFPlugin::TEnfVertexList(); ::BLSURFPlugin_Hypothesis::TEnfVertexList _vList = this->GetImpl()->GetEnfVertexList(entry); vertexList->length(_vList.size()); - MESSAGE("Number of enforced vertices: " << vertexList->length()); ::BLSURFPlugin_Hypothesis::TEnfVertexList::const_iterator evlIt = _vList.begin(); for (int i = 0; evlIt != _vList.end(); ++evlIt, ++i) { ::BLSURFPlugin_Hypothesis::TEnfVertex *_enfVertex = (*evlIt); @@ -2322,7 +3198,7 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntr // Coords BLSURFPlugin::TEnfVertexCoords_var coords = new BLSURFPlugin::TEnfVertexCoords(); coords->length(_enfVertex->coords.size()); - for (int ind=0;indlength();ind++) + for ( CORBA::ULong ind = 0; ind < coords->length(); ind++ ) coords[ind] = _enfVertex->coords[ind]; enfVertex->coords = coords; // Group Name @@ -2337,7 +3213,6 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntr vertexList[i] = enfVertex; } - MESSAGE("ENGINE : GetEnforcedVerticesEntry END ENTRY : " << entry); return vertexList._retn(); } catch (const std::invalid_argument& ex) { SALOME::ExceptionStruct ExDescription; @@ -2352,20 +3227,19 @@ BLSURFPlugin::TEnfVertexList* BLSURFPlugin_Hypothesis_i::GetEnforcedVerticesEntr } } -bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, - CORBA::Double z, const char* theVertexEntry) throw (SALOME::SALOME_Exception) { +bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntry, CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* theVertexEntry) throw (SALOME::SALOME_Exception) +{ ASSERT(myBaseImpl); - MESSAGE("IDL : UnsetEnforcedVertexEntry(" << theFaceEntry << "," << x << "," << y << "," << z << ", " << theVertexEntry << ")"); bool res = false; try { res = this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z, theVertexEntry); if (string(theVertexEntry).empty()) - SMESH::TPythonDump() << "isDone = " << _this() << ".UnsetEnforcedVertex(" << theFaceEntry << ", " << x << ", " << y << ", " << z - << ")"; + SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertex(" << x << ", " << y << ", " << z + << ")"; else - SMESH::TPythonDump() << "isDone = " << _this() << ".UnsetEnforcedVertexGeom(" << theFaceEntry << ", " << theVertexEntry << ")"; + SMESH::TPythonDump() << "isDone = " << _this() << ".RemoveEnforcedVertexGeom(" << theVertexEntry << ")"; } catch (const std::invalid_argument& ex) { return false; @@ -2374,44 +3248,21 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntry(const char* theFaceEntr THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - MESSAGE("ENGINE : UnsetEnforcedVertexEntry END ENTRY : " << theFaceEntry); return res; } - -//bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVertexEntryWithPoint(const char* theFaceEntry, const char* theVertexEntry, -// CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception) { -// MESSAGE("IDL : UnsetEnforcedVertexEntryWithPoint START theFaceEntry=" << theFaceEntry << ", theVertexEntry=" << theVertexEntry); -// -// bool ret = false; -// -// try { -// ret = _unsetEnfVertex(theFaceEntry, x, y, z); -// } catch (SALOME_Exception& ex) { -// THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); -// } -// -// if (ret) -// SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertexWithPoint(" << theFaceEntry << ", " << theVertexEntry -// << ")"; -// -// MESSAGE("IDL : UnsetEnforcedVertexEntryWithPoint END ENTRY : " << theFaceEntry); -// return ret; -//} - -bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception) { +bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEntry) throw (SALOME::SALOME_Exception) +{ ASSERT(myBaseImpl); - MESSAGE("IDL : UnsetEnforcedVerticesEntry(" << theFaceEntry << ")"); try { this->GetImpl()->ClearEnforcedVertices(theFaceEntry); - SMESH::TPythonDump() << _this() << ".UnsetEnforcedVertices(" << theFaceEntry << ")"; + SMESH::TPythonDump() << _this() << ".RemoveEnforcedVertices()"; } catch (const std::invalid_argument& ex) { return false; } catch (const std::exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - MESSAGE("IDL : UnsetEnforcedVerticesEntry END ENTRY : " << theFaceEntry); return true; } @@ -2422,8 +3273,8 @@ bool BLSURFPlugin_Hypothesis_i::UnsetEnforcedVerticesEntry(const char* theFaceEn * Set true or false */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFaces(CORBA::Boolean theValue) { - MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFaces"); +void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFaces(CORBA::Boolean theValue) +{ ASSERT(myBaseImpl); this->GetImpl()->SetInternalEnforcedVertexAllFaces(theValue); std::string theValueStr = theValue ? "True" : "False"; @@ -2437,8 +3288,8 @@ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFaces(CORBA::Boolean * Get true or false */ //============================================================================= -CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFaces() { - MESSAGE("BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFaces"); +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFaces() +{ ASSERT(myBaseImpl); return this->GetImpl()->_GetInternalEnforcedVertexAllFaces(); } @@ -2450,8 +3301,8 @@ CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFaces() { * Set group name */ //============================================================================= -void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFacesGroup(const char* groupName) { - MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFacesGroup"); +void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFacesGroup(const char* groupName) +{ ASSERT(myBaseImpl); this->GetImpl()->SetInternalEnforcedVertexAllFacesGroup(groupName); SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexAllFacesGroup( \"" << groupName << "\" )"; @@ -2464,8 +3315,8 @@ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexAllFacesGroup(const cha * Get group name */ //============================================================================= -char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup() { - MESSAGE("BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup"); +char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup() +{ ASSERT(myBaseImpl); return CORBA::string_dup(this->GetImpl()->_GetInternalEnforcedVertexAllFacesGroup().c_str()); } @@ -2473,125 +3324,115 @@ char* BLSURFPlugin_Hypothesis_i::GetInternalEnforcedVertexAllFacesGroup() { /* * Enable internal enforced vertices on specific face if requested by user * -void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices) + void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertex(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices) throw (SALOME::SALOME_Exception) -{ - MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFace"); - try { - SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices); - } catch (SALOME_Exception& ex) { - THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); - } -} + { + try { + SetInternalEnforcedVertexWithGroup(theFace, toEnforceInternalVertices); + } catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + } -void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName) + void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexWithGroup(GEOM::GEOM_Object_ptr theFace, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName) throw (SALOME::SALOME_Exception) -{ - MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFaceWithGroup"); - - if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { - MESSAGE("theFace shape type is not FACE or COMPOUND"); - THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); - } - - string theFaceEntry = theFace->GetStudyEntry(); - - if (theFaceEntry.empty()) { - GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); - SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); - string aName; - if (theFace->GetShapeType() == GEOM::FACE) - aName = "Face_"; - if (theFace->GetShapeType() == GEOM::COMPOUND) - aName = "Compound_"; - aName += theFace->GetEntry(); - SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str()); - if (!theSFace->_is_nil()) - theFaceEntry = theSFace->GetID(); - } - if (theFaceEntry.empty()) - THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); - - MESSAGE("IDL : GetName : " << theFace->GetName()); - MESSAGE("IDL : GetInternalEnforcedVertexEntry ( "<< theFaceEntry << ")"); - try { - SetInternalEnforcedVertexEntry(theFaceEntry.c_str(), toEnforceInternalVertices, theGroupName); - } catch (SALOME_Exception& ex) { - THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); - } -} + { -void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName) - throw (SALOME::SALOME_Exception) -{ - MESSAGE("BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexForFaceEntry"); - ASSERT(myBaseImpl); - try { - this->GetImpl()->SetInternalEnforcedVertex(theFaceEntry, toEnforceInternalVertices, theGroupName); - std::string theValueStr = toEnforceInternalVertices ? "True" : "False"; - if (string(theGroupName).empty()) - SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertex( " << theFaceEntry << ", " << theValueStr.c_str() << " )"; - else - SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexWithGroup( " << theFaceEntry << ", " << theValueStr.c_str() << ", \"" << theGroupName << "\" )"; - } catch (const std::exception& ex) { - std::cout << "Exception: " << ex.what() << std::endl; - THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); - } -} + if ((theFace->GetShapeType() != GEOM::FACE) && (theFace->GetShapeType() != GEOM::COMPOUND)) { + THROW_SALOME_CORBA_EXCEPTION("theFace shape type is not FACE or COMPOUND", SALOME::BAD_PARAM); + } -*/ + string theFaceEntry = theFace->GetStudyEntry(); + + if (theFaceEntry.empty()) { + GEOM::GEOM_Gen_ptr geomGen = SMESH_Gen_i::GetGeomEngine(); + SMESH_Gen_i *smeshGen = SMESH_Gen_i::GetSMESHGen(); + string aName; + if (theFace->GetShapeType() == GEOM::FACE) + aName = "Face_"; + if (theFace->GetShapeType() == GEOM::COMPOUND) + aName = "Compound_"; + aName += theFace->GetEntry(); + SALOMEDS::SObject_wrap theSFace = geomGen->PublishInStudy(smeshGen->GetCurrentStudy(), NULL, theFace, aName.c_str()); + if (!theSFace->_is_nil()) + theFaceEntry = theSFace->GetID(); + } + if (theFaceEntry.empty()) + THROW_SALOME_CORBA_EXCEPTION( "Geom object is not published in study" ,SALOME::BAD_PARAM ); -/* TODO GROUPS - char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z) - throw (SALOME::SALOME_Exception) - { - ASSERT(myBaseImpl); - MESSAGE("ENGINE : GetEnforcedVertexGroupName START "); try { - return CORBA::string_dup( this->GetImpl()->GetEnforcedVertexGroupName(x, y, z).c_str()); - } - catch (const std::invalid_argument& ex) { - SALOME::ExceptionStruct ExDescription; - ExDescription.text = ex.what(); - ExDescription.type = SALOME::BAD_PARAM; - ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(entry)"; - ExDescription.lineNumber = 1146; - throw SALOME::SALOME_Exception(ExDescription); - } - catch (SALOME_Exception& ex) { + SetInternalEnforcedVertexEntry(theFaceEntry.c_str(), toEnforceInternalVertices, theGroupName); + } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } - MESSAGE("ENGINE : GetEnforcedVertexGroupName END "); - return 0; } - - void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName) + void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFaceEntry, CORBA::Boolean toEnforceInternalVertices, const char* theGroupName) throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); - MESSAGE("ENGINE : SetEnforcedVertexGroupName START "); try { - this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName); - } - catch (const std::invalid_argument& ex) { - SALOME::ExceptionStruct ExDescription; - ExDescription.text = ex.what(); - ExDescription.type = SALOME::BAD_PARAM; - ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(x,y,z)"; - ExDescription.lineNumber = 1170; - throw SALOME::SALOME_Exception(ExDescription); - } - catch (SALOME_Exception& ex) { + this->GetImpl()->SetInternalEnforcedVertex(theFaceEntry, toEnforceInternalVertices, theGroupName); + std::string theValueStr = toEnforceInternalVertices ? "True" : "False"; + if (string(theGroupName).empty()) + SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertex( " << theFaceEntry << ", " << theValueStr.c_str() << " )"; + else + SMESH::TPythonDump() << _this() << ".SetInternalEnforcedVertexWithGroup( " << theFaceEntry << ", " << theValueStr.c_str() << ", \"" << theGroupName << "\" )"; + } catch (const std::exception& ex) { + std::cout << "Exception: " << ex.what() << std::endl; THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } + } - SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName(" - << x << ", " << y << ", " << z << ", '" << groupName << "' )"; +*/ - MESSAGE("ENGINE : SetEnforcedVertexGroupName END "); - } - */ +/* TODO GROUPS + char* BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z) + throw (SALOME::SALOME_Exception) + { + ASSERT(myBaseImpl); + try { + return CORBA::string_dup( this->GetImpl()->GetEnforcedVertexGroupName(x, y, z).c_str()); + } + catch (const std::invalid_argument& ex) { + SALOME::ExceptionStruct ExDescription; + ExDescription.text = ex.what(); + ExDescription.type = SALOME::BAD_PARAM; + ExDescription.sourceFile = "BLSURFPlugin_Hypothesis_i::GetEnforcedVertexGroupName(entry)"; + ExDescription.lineNumber = 1146; + throw SALOME::SALOME_Exception(ExDescription); + } + catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + return 0; + } + + + void BLSURFPlugin_Hypothesis_i::SetEnforcedVertexGroupName(CORBA::Double x, CORBA::Double y, CORBA::Double z, const char* groupName) + throw (SALOME::SALOME_Exception) + { + ASSERT(myBaseImpl); + try { + this->GetImpl()->SetEnforcedVertexGroupName(x, y, z, groupName); + } + catch (const std::invalid_argument& ex) { + SALOME::ExceptionStruct ExDescription; + ExDescription.text = ex.what(); + ExDescription.type = SALOME::BAD_PARAM; + ExDescription.sourceFile = "BLSURFPlugin_Hypothesis::SetEnforcedVertexGroupName(x,y,z)"; + ExDescription.lineNumber = 1170; + throw SALOME::SALOME_Exception(ExDescription); + } + catch (SALOME_Exception& ex) { + THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + } + + SMESH::TPythonDump() << _this() << ".SetEnforcedVertexGroupName(" + << x << ", " << y << ", " << z << ", '" << groupName << "' )"; + + } +*/ /////////////////////// /////////////////////// @@ -2601,7 +3442,6 @@ void BLSURFPlugin_Hypothesis_i::SetInternalEnforcedVertexEntry(const char* theFa std::string BLSURFPlugin_Hypothesis_i::ShapeTypeToString(GEOM::shape_type theShapeType) { -//enum shape_type { COMPOUND, COMPSOLID, SOLID, SHELL, FACE, WIRE, EDGE, VERTEX, SHAPE /*, __max_shape_type=0xffffffff */ }; std::map MapShapeTypeToString; MapShapeTypeToString[GEOM::COMPOUND] = std::string("COMPOUND"); MapShapeTypeToString[GEOM::COMPSOLID] = std::string("COMPSOLID"); @@ -2622,18 +3462,17 @@ void BLSURFPlugin_Hypothesis_i::CheckShapeTypes(GEOM::GEOM_Object_ptr shape, std bool ok = false; std::stringstream typesTxt; for (std::size_t i=0; iGetShapeType() == theShapeType) - ok = true; - typesTxt << ShapeTypeToString(theShapeType); - if (i < theShapeTypes.size()-1 ) - typesTxt << ", "; - } + { + GEOM::shape_type theShapeType = theShapeTypes[i]; + if (shape->GetShapeType() == theShapeType) + ok = true; + typesTxt << ShapeTypeToString(theShapeType); + if (i < theShapeTypes.size()-1 ) + typesTxt << ", "; + } if (!ok){ std::stringstream msg; - msg << "shape shape type is not in" << typesTxt; - MESSAGE(msg); + msg << "shape type is not in" << typesTxt.str(); THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM); } } @@ -2644,7 +3483,6 @@ void BLSURFPlugin_Hypothesis_i::CheckShapeType(GEOM::GEOM_Object_ptr shape, GEOM if (shape->GetShapeType() != theShapeType) { std::stringstream msg; msg << "shape shape type is not " << ShapeTypeToString(theShapeType); - MESSAGE(msg); THROW_SALOME_CORBA_EXCEPTION(msg.str().c_str(), SALOME::BAD_PARAM); } } @@ -2678,26 +3516,26 @@ std::string BLSURFPlugin_Hypothesis_i::FormatVerticesEntries(vector &the std::stringstream listEntriesTxt; if (!theSourceVerticesEntries.empty()) + { + listEntriesTxt << ", [" ; + size_t i =0; + for (std::vector::const_iterator it = theSourceVerticesEntries.begin(); it != theSourceVerticesEntries.end(); it++, i++) { - listEntriesTxt << ", [" ; - size_t i =0; - for (std::vector::const_iterator it = theSourceVerticesEntries.begin(); it != theSourceVerticesEntries.end(); it++, i++) - { - if (i>0) - listEntriesTxt << ", "; - listEntriesTxt << *it; - } + if (i>0) + listEntriesTxt << ", "; + listEntriesTxt << *it; + } - listEntriesTxt << "], [" ; - i =0; - for (std::vector::const_iterator it = theTargetVerticesEntries.begin(); it != theTargetVerticesEntries.end(); it++, i++) - { - if (i>0) - listEntriesTxt << ", "; - listEntriesTxt << *it; - } - listEntriesTxt << "]" ; + listEntriesTxt << "], [" ; + i =0; + for (std::vector::const_iterator it = theTargetVerticesEntries.begin(); it != theTargetVerticesEntries.end(); it++, i++) + { + if (i>0) + listEntriesTxt << ", "; + listEntriesTxt << *it; } + listEntriesTxt << "]" ; + } return listEntriesTxt.str(); } @@ -2712,66 +3550,61 @@ void BLSURFPlugin_Hypothesis_i::ClearPreCadPeriodicityVectors() { BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector() { - MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector"); const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector = - this->GetImpl()->_GetPreCadFacesPeriodicityVector(); + this->GetImpl()->_GetPreCadFacesPeriodicityVector(); BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector); - MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadFacesPeriodicityVector end"); return periodicityList._retn(); } BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector() { - MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector"); const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector preCadPeriodicityVector = - this->GetImpl()->_GetPreCadEdgesPeriodicityVector(); + this->GetImpl()->_GetPreCadEdgesPeriodicityVector(); BLSURFPlugin::TPeriodicityList_var periodicityList = PreCadVectorToSequence(preCadPeriodicityVector); - MESSAGE("BLSURFPlugin_Hypothesis_i::GetPreCadEdgesPeriodicityVector end"); return periodicityList._retn(); } // convert a vector preCadPeriodicityVector into TPeriodicityList Corba sequence BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::PreCadVectorToSequence(const ::BLSURFPlugin_Hypothesis::TPreCadPeriodicityVector& preCadPeriodicityVector) { - MESSAGE("BLSURFPlugin_Hypothesis_i::PreCadVectorToSequence"); BLSURFPlugin::TPeriodicityList_var periodicityList = new BLSURFPlugin::TPeriodicityList(); - periodicityList->length(preCadPeriodicityVector.size()); + periodicityList->length(preCadPeriodicityVector.size()); - for (size_t i = 0; ishape1Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape1Entry.c_str()); - myPreCadPeriodicity->shape2Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape2Entry.c_str()); + BLSURFPlugin::TPreCadPeriodicity_var myPreCadPeriodicity = new BLSURFPlugin::TPreCadPeriodicity(); + myPreCadPeriodicity->shape1Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape1Entry.c_str()); + myPreCadPeriodicity->shape2Entry = CORBA::string_dup(preCadPeriodicityVector_i.shape2Entry.c_str()); - BLSURFPlugin::TEntryList_var sourceVertices = new BLSURFPlugin::TEntryList(); - if (! preCadPeriodicityVector_i.theSourceVerticesEntries.empty()) - { - sourceVertices->length(preCadPeriodicityVector_i.theSourceVerticesEntries.size()); - for (size_t j=0; jlength(preCadPeriodicityVector_i.theSourceVerticesEntries.size()); + for (size_t j=0; jtheSourceVerticesEntries = sourceVertices; + myPreCadPeriodicity->theSourceVerticesEntries = sourceVertices; - BLSURFPlugin::TEntryList_var targetVertices = new BLSURFPlugin::TEntryList(); - if (! preCadPeriodicityVector_i.theTargetVerticesEntries.empty()) - { - targetVertices->length(preCadPeriodicityVector_i.theTargetVerticesEntries.size()); - for (size_t j=0; jlength(preCadPeriodicityVector_i.theTargetVerticesEntries.size()); + for (size_t j=0; jtheTargetVerticesEntries = targetVertices; + myPreCadPeriodicity->theTargetVerticesEntries = targetVertices; - periodicityList[i] = myPreCadPeriodicity; - } + periodicityList[i] = myPreCadPeriodicity; + } return periodicityList._retn(); @@ -2779,7 +3612,7 @@ BLSURFPlugin::TPeriodicityList* BLSURFPlugin_Hypothesis_i::PreCadVectorToSequenc void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2) -throw (SALOME::SALOME_Exception) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); const GEOM::ListOfGO theSourceVertices; @@ -2789,11 +3622,10 @@ throw (SALOME::SALOME_Exception) void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2, - const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices) -throw (SALOME::SALOME_Exception) + const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); - MESSAGE("BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityWithVertices"); size_t theLength = theSourceVertices.length(); if (theLength != theTargetVertices.length()) @@ -2817,27 +3649,24 @@ throw (SALOME::SALOME_Exception) GEOM::GEOM_Object_ptr theVtx_i; string theEntry_i; for (size_t ind = 0; ind < theLength; ind++) { - theVtx_i = theSourceVertices[ind]; - theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3); - theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); + theVtx_i = theSourceVertices[ind]; + theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3); + theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); } string prefix4 = "Target_vertex_"; BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList(); theTargetVerticesEntries->length(theLength); for (size_t ind = 0; ind < theLength; ind++) { - theVtx_i = theTargetVertices[ind]; - theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4); - theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); + theVtx_i = theTargetVertices[ind]; + theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4); + theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); } string theFace2Name = theFace2->GetName(); - MESSAGE("IDL : theFace1->GetName : " << theFace1->GetName()); - MESSAGE("IDL : theFace2->GetName : " << theFace2->GetName()); - MESSAGE("IDL : AddPreCadFacesPeriodicity( "<< theFace1Entry << ", " << theFace2Entry << ")"); try { - AddPreCadFacesPeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str(), - theSourceVerticesEntries, theTargetVerticesEntries); + AddPreCadFacesPeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str(), + theSourceVerticesEntries, theTargetVerticesEntries); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } @@ -2845,8 +3674,8 @@ throw (SALOME::SALOME_Exception) void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFace1Entry, const char* theFace2Entry, - const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba) - throw (SALOME::SALOME_Exception) + const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); @@ -2854,31 +3683,29 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadFacesPeriodicityEntry(const char* theFa // Convert BLSURFPlugin::TEntryList to vector vector theSourceVerticesEntries, theTargetVerticesEntries; for (size_t ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) { - theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in()); - theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in()); + theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in()); + theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in()); } string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries); - MESSAGE("IDL : AddPreCadFacesPeriodicityEntry(" << theFace1Entry << ", " << theFace2Entry << listEntriesTxt.c_str() << ")"); this->GetImpl()->AddPreCadFacesPeriodicity(theFace1Entry, theFace2Entry, - theSourceVerticesEntries, theTargetVerticesEntries); + theSourceVerticesEntries, theTargetVerticesEntries); SMESH::TPythonDump pd; if (!theSourceVerticesEntries.empty()) - { - pd << _this() << ".AddPreCadFacesPeriodicityWithVertices(" << theFace1Entry << ", " << theFace2Entry; - pd << listEntriesTxt.c_str(); - pd << ")"; - } + { + pd << _this() << ".AddPreCadFacesPeriodicityWithVertices(" << theFace1Entry << ", " << theFace2Entry; + pd << listEntriesTxt.c_str(); + pd << ")"; + } else pd << _this() << ".AddPreCadFacesPeriodicity(" << theFace1Entry << ", " << theFace2Entry << ")"; - MESSAGE("IDL : AddPreCadFacesPeriodicityEntry END"); } void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2) - throw (SALOME::SALOME_Exception) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); const GEOM::ListOfGO theSourceVertices; @@ -2887,10 +3714,9 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicity(GEOM::GEOM_Object_ptr } void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theEdge2, - const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices) - throw (SALOME::SALOME_Exception) + const GEOM::ListOfGO& theSourceVertices, const GEOM::ListOfGO& theTargetVertices) + throw (SALOME::SALOME_Exception) { - MESSAGE("BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices"); ASSERT(myBaseImpl); size_t theLength = theSourceVertices.length(); @@ -2915,27 +3741,24 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM GEOM::GEOM_Object_ptr theVtx_i; string theEntry_i; for (size_t ind = 0; ind < theLength; ind++) { - theVtx_i = theSourceVertices[ind]; - theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3); - theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); + theVtx_i = theSourceVertices[ind]; + theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix3); + theSourceVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); } string prefix4 = "Target_vertex_"; BLSURFPlugin::TEntryList_var theTargetVerticesEntries = new BLSURFPlugin::TEntryList(); theTargetVerticesEntries->length(theLength); for (size_t ind = 0; ind < theLength; ind++) { - theVtx_i = theTargetVertices[ind]; - theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4); - theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); + theVtx_i = theTargetVertices[ind]; + theEntry_i = PublishIfNeeded(theVtx_i, GEOM::VERTEX, prefix4); + theTargetVerticesEntries[ind] = CORBA::string_dup(theEntry_i.c_str()); } string theEdge2Name = theEdge2->GetName(); - MESSAGE("IDL : theEdge1->GetName : " << theEdge1->GetName()); - MESSAGE("IDL : theEdge2->GetName : " << theEdge2->GetName()); - MESSAGE("IDL : AddPreCadEdgesPeriodicity( "<< theEdge1Entry << ", " << theEdge2Entry << ")"); try { - AddPreCadEdgesPeriodicityEntry(theEdge1Entry.c_str(), theEdge2Entry.c_str(), - theSourceVerticesEntries, theTargetVerticesEntries); + AddPreCadEdgesPeriodicityEntry(theEdge1Entry.c_str(), theEdge2Entry.c_str(), + theSourceVerticesEntries, theTargetVerticesEntries); } catch (SALOME_Exception& ex) { THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); } @@ -2943,8 +3766,8 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityWithVertices(GEOM::GEOM void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEdge1Entry, const char* theEdge2Entry, - const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba) - throw (SALOME::SALOME_Exception) + const BLSURFPlugin::TEntryList& theSourceVerticesEntriesCorba, const BLSURFPlugin::TEntryList& theTargetVerticesEntriesCorba) + throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); @@ -2952,186 +3775,25 @@ void BLSURFPlugin_Hypothesis_i::AddPreCadEdgesPeriodicityEntry(const char* theEd // Convert BLSURFPlugin::TEntryList to vector vector theSourceVerticesEntries, theTargetVerticesEntries; for (size_t ind = 0; ind < theSourceVerticesEntriesCorba.length(); ind++) { - theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in()); - theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in()); + theSourceVerticesEntries.push_back(theSourceVerticesEntriesCorba[ind].in()); + theTargetVerticesEntries.push_back(theTargetVerticesEntriesCorba[ind].in()); } string listEntriesTxt = FormatVerticesEntries(theSourceVerticesEntries, theTargetVerticesEntries); - MESSAGE("IDL : AddPreCadEdgesPeriodicityEntry(" << theEdge1Entry << ", " << theEdge2Entry << listEntriesTxt.c_str() << ")"); this->GetImpl()->AddPreCadEdgesPeriodicity(theEdge1Entry, theEdge2Entry, - theSourceVerticesEntries, theTargetVerticesEntries); + theSourceVerticesEntries, theTargetVerticesEntries); SMESH::TPythonDump pd; if (!theSourceVerticesEntries.empty()) - { - pd << _this() << ".AddPreCadEdgesPeriodicityWithVertices(" << theEdge1Entry << ", " << theEdge2Entry; - pd << listEntriesTxt.c_str(); - pd << ")"; - } - else - pd << _this() << ".AddPreCadEdgesPeriodicity(" << theEdge1Entry << ", " << theEdge2Entry << ")"; - - MESSAGE("IDL : AddPreCadEdgesPeriodicityEntry END"); -} - -void BLSURFPlugin_Hypothesis_i::AddFacePeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theFace2) - throw (SALOME::SALOME_Exception) -{ - ASSERT(myBaseImpl); - - string prefix1 = "Source_face_"; - CheckShapeType(theFace1, GEOM::FACE); - string theFace1Entry = PublishIfNeeded(theFace1, GEOM::FACE, prefix1); - string prefix2 = "Target_face_"; - CheckShapeType(theFace2, GEOM::FACE); - string theFace2Entry = PublishIfNeeded(theFace2, GEOM::FACE, prefix2); - - MESSAGE("IDL : theFace1->GetName : " << theFace1->GetName()); - MESSAGE("IDL : theFace2->GetName : " << theFace2->GetName()); - MESSAGE("IDL : AddFacePeriodicity( "<< theFace1Entry << ", " << theFace2Entry << ")"); - try { - AddFacePeriodicityEntry(theFace1Entry.c_str(), theFace2Entry.c_str()); - } catch (SALOME_Exception& ex) { - THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); - } - - -} - -void BLSURFPlugin_Hypothesis_i::AddFacePeriodicityEntry(const char* theFace1Entry, const char* theFace2Entry) - throw (SALOME::SALOME_Exception){ - - ASSERT(myBaseImpl); - - MESSAGE("IDL : AddFacePeriodicityEntry(" << theFace1Entry << ", " << theFace2Entry << ")"); - this->GetImpl()->AddFacePeriodicity(theFace1Entry, theFace2Entry); - SMESH::TPythonDump pd; - pd << _this() << ".AddFacePeriodicity(" << theFace1Entry << ", " << theFace2Entry << ")"; - MESSAGE("IDL : AddFacePeriodicityEntry END"); -} - - -void BLSURFPlugin_Hypothesis_i::AddEdgePeriodicity(GEOM::GEOM_Object_ptr theFace1, GEOM::GEOM_Object_ptr theEdge1, - GEOM::GEOM_Object_ptr theFace2, GEOM::GEOM_Object_ptr theEdge2, - CORBA::Long edge_orientation) - throw (SALOME::SALOME_Exception){ - ASSERT(myBaseImpl); - - string prefix_theFace1 = "Source_face_"; - CheckShapeType(theFace1, GEOM::FACE); - string theFace1Entry = PublishIfNeeded(theFace1, GEOM::FACE, prefix_theFace1); - string prefix_theFace2 = "Target_face_"; - CheckShapeType(theFace2, GEOM::FACE); - string theFace2Entry = PublishIfNeeded(theFace2, GEOM::FACE, prefix_theFace2); - - string prefix_theEdge1 = "Source_edge_"; - CheckShapeType(theEdge1, GEOM::EDGE); - string theEdge1Entry = PublishIfNeeded(theEdge1, GEOM::EDGE, prefix_theEdge1); - string prefix_theEdge2 = "Target_edge_"; - CheckShapeType(theEdge2, GEOM::EDGE); - string theEdge2Entry = PublishIfNeeded(theEdge2, GEOM::EDGE, prefix_theEdge2); - - MESSAGE("IDL : theFace1->GetName : " << theFace1->GetName()); - MESSAGE("IDL : theEdge1->GetName : " << theEdge1->GetName()); - MESSAGE("IDL : theFace2->GetName : " << theFace2->GetName()); - MESSAGE("IDL : theEdge2->GetName : " << theEdge2->GetName()); - MESSAGE("IDL : AddEdgePeriodicity( "<< theFace1Entry << ", " << theEdge1Entry << ", " << theFace2Entry << ", " << theEdge2Entry << ", " << edge_orientation << ")"); - try { - AddEdgePeriodicityEntry(theFace1Entry.c_str(), theEdge1Entry.c_str(), theFace2Entry.c_str(), theEdge2Entry.c_str(), edge_orientation); - } catch (SALOME_Exception& ex) { - THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); + { + pd << _this() << ".AddPreCadEdgesPeriodicityWithVertices(" << theEdge1Entry << ", " << theEdge2Entry; + pd << listEntriesTxt.c_str(); + pd << ")"; } - - -} - -void BLSURFPlugin_Hypothesis_i::AddEdgePeriodicityWithoutFaces(GEOM::GEOM_Object_ptr theEdge1, - GEOM::GEOM_Object_ptr theEdge2, - CORBA::Long edge_orientation) - throw (SALOME::SALOME_Exception){ - ASSERT(myBaseImpl); - - string theFace1Entry = ""; - string theFace2Entry = ""; - - string prefix_theEdge1 = "Source_edge_"; - CheckShapeType(theEdge1, GEOM::EDGE); - string theEdge1Entry = PublishIfNeeded(theEdge1, GEOM::EDGE, prefix_theEdge1); - string prefix_theEdge2 = "Target_edge_"; - CheckShapeType(theEdge2, GEOM::EDGE); - string theEdge2Entry = PublishIfNeeded(theEdge2, GEOM::EDGE, prefix_theEdge2); - - MESSAGE("IDL : theEdge1->GetName : " << theEdge1->GetName()); - MESSAGE("IDL : theEdge2->GetName : " << theEdge2->GetName()); - MESSAGE("IDL : AddEdgePeriodicity( "<< theFace1Entry << ", " << theEdge1Entry << ", " << theFace2Entry << ", " << theEdge2Entry << ", " << edge_orientation << ")"); - try { - AddEdgePeriodicityEntry(theFace1Entry.c_str(), theEdge1Entry.c_str(), theFace2Entry.c_str(), theEdge2Entry.c_str(), edge_orientation); - } catch (SALOME_Exception& ex) { - THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); - } - - -} - -void BLSURFPlugin_Hypothesis_i::AddEdgePeriodicityEntry(const char* theFace1Entry, const char* theEdge1Entry, const char* theFace2Entry, const char* theEdge2Entry, const long edge_orientation) - throw (SALOME::SALOME_Exception){ - - ASSERT(myBaseImpl); - - MESSAGE("IDL : AddEdgePeriodicityEntry(" << theFace1Entry << ", " << theEdge1Entry << ", " << theFace2Entry << ", " << theEdge2Entry << ", " << edge_orientation << ")"); - this->GetImpl()->AddEdgePeriodicity(theFace1Entry, theEdge1Entry, theFace2Entry, theEdge2Entry, edge_orientation); - SMESH::TPythonDump pd; - if (theFace1Entry) - pd << _this() << ".AddEdgePeriodicity(" << theFace1Entry << ", " << theEdge1Entry << ", " << theFace2Entry << ", " << theEdge2Entry << ", " << edge_orientation <<")"; else - pd << _this() << ".AddEdgePeriodicityWithoutFaces(" << theEdge1Entry << ", " << theEdge2Entry << ", " << edge_orientation <<")"; - MESSAGE("IDL : AddEdgePeriodicityEntry END"); -} - -void BLSURFPlugin_Hypothesis_i::AddVertexPeriodicity(GEOM::GEOM_Object_ptr theEdge1, GEOM::GEOM_Object_ptr theVertex1, - GEOM::GEOM_Object_ptr theEdge2, GEOM::GEOM_Object_ptr theVertex2) - throw (SALOME::SALOME_Exception){ - ASSERT(myBaseImpl); - - string prefix_theEdge1 = "Source_edge_"; - CheckShapeType(theEdge1, GEOM::EDGE); - string theEdge1Entry = PublishIfNeeded(theEdge1, GEOM::EDGE, prefix_theEdge1); - string prefix_theEdge2 = "Target_edge_"; - CheckShapeType(theEdge2, GEOM::EDGE); - string theEdge2Entry = PublishIfNeeded(theEdge2, GEOM::EDGE, prefix_theEdge2); - - string prefix_theVertex1 = "Source_vertex_"; - CheckShapeType(theVertex1, GEOM::VERTEX); - string theVertex1Entry = PublishIfNeeded(theVertex1, GEOM::VERTEX, prefix_theVertex1); - string prefix_theVertex2 = "Target_vertex_"; - CheckShapeType(theVertex2, GEOM::VERTEX); - string theVertex2Entry = PublishIfNeeded(theVertex2, GEOM::VERTEX, prefix_theVertex2); - - MESSAGE("IDL : theEdge1->GetName : " << theEdge1->GetName()); - MESSAGE("IDL : theVertex1->GetName : " << theVertex1->GetName()); - MESSAGE("IDL : theEdge2->GetName : " << theEdge2->GetName()); - MESSAGE("IDL : theVertex2->GetName : " << theVertex2->GetName()); - MESSAGE("IDL : AddVertexPeriodicity( "<< theEdge1Entry << ", " << theVertex1Entry << ", " << theEdge2Entry << ", " << theVertex2Entry << ")"); - try { - AddVertexPeriodicityEntry(theEdge1Entry.c_str(), theVertex1Entry.c_str(), theEdge2Entry.c_str(), theVertex2Entry.c_str()); - } catch (SALOME_Exception& ex) { - THROW_SALOME_CORBA_EXCEPTION( ex.what() ,SALOME::BAD_PARAM ); - } - - -} - -void BLSURFPlugin_Hypothesis_i::AddVertexPeriodicityEntry(const char* theEdge1Entry, const char* theVertex1Entry, const char* theEdge2Entry, const char* theVertex2Entry) - throw (SALOME::SALOME_Exception){ - - ASSERT(myBaseImpl); + pd << _this() << ".AddPreCadEdgesPeriodicity(" << theEdge1Entry << ", " << theEdge2Entry << ")"; - MESSAGE("IDL : AddVertexPeriodicityEntry(" << theEdge1Entry << ", " << theVertex1Entry << ", " << theEdge2Entry << ", " << theVertex2Entry << ")"); - this->GetImpl()->AddVertexPeriodicity(theEdge1Entry, theVertex1Entry, theEdge2Entry, theVertex2Entry); - SMESH::TPythonDump pd; - pd << _this() << ".AddVertexPeriodicity(" << theEdge1Entry << ", " << theVertex1Entry << ", " << theEdge2Entry << ", " << theVertex2Entry << ")"; - MESSAGE("IDL : AddVertexPeriodicityEntry END"); } @@ -3146,11 +3808,10 @@ void BLSURFPlugin_Hypothesis_i::AddVertexPeriodicityEntry(const char* theEdge1En // void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName, CORBA::Boolean isBinary) { void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) { ASSERT(myBaseImpl); - MESSAGE("IDL : SetGMFFile(" << theFileName << ")"); bool valueChanged/*, modeChanged*/ = false; try { valueChanged = (this->GetImpl()->GetGMFFile() != theFileName); -// modeChanged = (this->GetImpl()->GetGMFFileMode() != isBinary); + // modeChanged = (this->GetImpl()->GetGMFFileMode() != isBinary); if (valueChanged)// or (!valueChanged && modeChanged)) this->GetImpl()->SetGMFFile(theFileName);// ,isBinary); } catch (const std::exception& ex) { @@ -3158,7 +3819,6 @@ void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) { } if (valueChanged)// or (!valueChanged && modeChanged)) SMESH::TPythonDump() << _this() << ".SetGMFFile(\"" << theFileName << "\")"; //", " << isBinary << ")"; - MESSAGE("IDL : SetGMFFile END "); } //================================================================================ @@ -3171,7 +3831,6 @@ void BLSURFPlugin_Hypothesis_i::SetGMFFile(const char* theFileName) { //================================================================================ char* BLSURFPlugin_Hypothesis_i::GetGMFFile() { ASSERT(myBaseImpl); -// MESSAGE("IDL : GetGMFFile()"); return CORBA::string_dup(this->GetImpl()->GetGMFFile().c_str()); } @@ -3185,7 +3844,6 @@ char* BLSURFPlugin_Hypothesis_i::GetGMFFile() { // //================================================================================ // CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetGMFFileMode() { // ASSERT(myBaseImpl); -// MESSAGE("IDL : GetGMFFileMode()"); // return this->GetImpl()->GetGMFFileMode(); // } @@ -3197,7 +3855,6 @@ char* BLSURFPlugin_Hypothesis_i::GetGMFFile() { */ //============================================================================= ::BLSURFPlugin_Hypothesis* BLSURFPlugin_Hypothesis_i::GetImpl() { - // MESSAGE("BLSURFPlugin_Hypothesis_i::GetImpl"); return (::BLSURFPlugin_Hypothesis*) myBaseImpl; } @@ -3261,26 +3918,26 @@ void BLSURFPlugin_Hypothesis_i::SetDecimesh(CORBA::Boolean theValue) { CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetDecimesh() { std::string theValueStr = this->GetOptionValue("respect_geometry"); if (theValueStr.empty() || theValueStr == "respect") - return true; + return true; return false; } void BLSURFPlugin_Hypothesis_i::SetPreCADRemoveNanoEdges(CORBA::Boolean theValue) { std::string theValueStr = theValue ? "1" : "0"; - this->SetPreCADOptionValue("remove_tiny_edges",theValueStr.c_str()); + this->AddPreCADOption("remove_tiny_edges",theValueStr.c_str()); } CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetPreCADRemoveNanoEdges() { - std::string theValueStr = this->GetPreCADOptionValue("remove_tiny_edges"); + std::string theValueStr = this->GetPreCADOption("remove_tiny_edges"); if (theValueStr == "1") - return true; + return true; return false; } void BLSURFPlugin_Hypothesis_i::SetPreCADEpsNano(CORBA::Double theValue) { std::ostringstream theValueStr; theValueStr << theValue; - this->SetPreCADOptionValue("tiny_edge_length",theValueStr.str().c_str()); + this->AddPreCADOption("tiny_edge_length",theValueStr.str().c_str()); } CORBA::Double BLSURFPlugin_Hypothesis_i::GetPreCADEpsNano() { - std::istringstream theValueStr(this->GetPreCADOptionValue("tiny_edge_length")); + std::istringstream theValueStr(this->GetPreCADOption("tiny_edge_length")); double result; theValueStr >> result; return result;