-// Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : SMESH_subMesh.cxx
{
MESSAGE("SMESH_subMesh::~SMESH_subMesh");
// ****
- DeleteOwnListeners();
+ deleteOwnListeners();
}
//=============================================================================
*/
//=============================================================================
+const SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS() const
+{
+ return ((SMESH_subMesh*) this )->GetSubMeshDS();
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
SMESHDS_SubMesh* SMESH_subMesh::CreateSubMeshDS()
{
if ( !GetSubMeshDS() ) {
*/
//=============================================================================
-bool SMESH_subMesh::SubMeshesComputed()
+bool SMESH_subMesh::subMeshesComputed()
{
int myDim = SMESH_Gen::GetShapeDim( _subShape );
int dimToCheck = myDim - 1;
*/
//=============================================================================
-bool SMESH_subMesh::SubMeshesReady()
-{
- bool subMeshesReady = true;
- SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
- while ( smIt->more() ) {
- SMESH_subMesh *sm = smIt->next();
- bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
- sm->GetComputeState() == READY_TO_COMPUTE);
- if (!computeOk)
- {
- subMeshesReady = false;
- SCRUTE(sm->GetId());
- break;
- }
- }
- return subMeshesReady;
-}
+// bool SMESH_subMesh::SubMeshesReady()
+// {
+// bool subMeshesReady = true;
+// SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
+// while ( smIt->more() ) {
+// SMESH_subMesh *sm = smIt->next();
+// bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
+// sm->GetComputeState() == READY_TO_COMPUTE);
+// if (!computeOk)
+// {
+// subMeshesReady = false;
+// SCRUTE(sm->GetId());
+// break;
+// }
+// }
+// return subMeshesReady;
+// }
//=============================================================================
/*!
//MESSAGE("compound");
for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More();exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
for (TopExp_Explorer exp(_subShape, TopAbs_SHELL, TopAbs_SOLID); exp.More(); exp.Next())
{
if ( BRep_Tool::IsClosed(exp.Current() ))
- InsertDependence(exp.Current()); //only shell not in solid
+ insertDependence(exp.Current()); //only shell not in solid
else
for (TopExp_Explorer expF(exp.Current(), TopAbs_FACE); expF.More();expF.Next())
- InsertDependence(expF.Current()); // issue 0020959: HEXA_3D fails on shell
+ insertDependence(expF.Current()); // issue 0020959: HEXA_3D fails on shell
}
for (TopExp_Explorer exp(_subShape, TopAbs_FACE, TopAbs_SHELL); exp.More();exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE, TopAbs_FACE); exp.More();exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
+ }
+ for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX, TopAbs_EDGE); exp.More();exp.Next())
+ {
+ insertDependence(exp.Current());
}
break;
}
//MESSAGE("compsolid");
for (TopExp_Explorer exp(_subShape, TopAbs_SOLID); exp.More(); exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
break;
}
//MESSAGE("shell");
for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More(); exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
break;
}
//MESSAGE("wire");
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More(); exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
break;
}
if(_father->HasShapeToMesh()) {
for (TopExp_Explorer exp(_subShape, TopAbs_FACE); exp.More();exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
}
break;
//MESSAGE("face");
for (TopExp_Explorer exp(_subShape, TopAbs_EDGE); exp.More();exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
break;
}
//MESSAGE("edge");
for (TopExp_Explorer exp(_subShape, TopAbs_VERTEX); exp.More(); exp.Next())
{
- InsertDependence(exp.Current());
+ insertDependence(exp.Current());
}
break;
}
*/
//=============================================================================
-void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape)
+void SMESH_subMesh::insertDependence(const TopoDS_Shape aSubShape)
{
- //MESSAGE("SMESH_subMesh::InsertDependence");
SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape);
int type = aSubShape.ShapeType();
int ordType = 9 - type; // 2 = Vertex, 8 = CompSolid
if ( ! CanAddHypothesis( anHyp )) // check dimension
return SMESH_Hypothesis::HYP_BAD_DIM;
- if ( /*!anHyp->IsAuxiliary() &&*/ GetSimilarAttached( _subShape, anHyp ) )
+ if ( /*!anHyp->IsAuxiliary() &&*/ getSimilarAttached( _subShape, anHyp ) )
return SMESH_Hypothesis::HYP_ALREADY_EXIST;
if ( !meshDS->AddHypothesis(_subShape, anHyp))
algo = GetAlgo();
ASSERT(algo);
if (algo->CheckHypothesis((*_father),_subShape, aux_ret))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else if ( algo->IsStatusFatal( aux_ret )) {
meshDS->RemoveHypothesis(_subShape, anHyp);
ret = aux_ret;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
break;
}
case REMOVE_HYP:
ASSERT(algo);
if ( algo == anHyp ) {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
if (algo)
{
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
algo = GetAlgo();
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, ret ))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
if (SMESH_Hypothesis::IsStatusFatal( ret ))
meshDS->RemoveHypothesis(_subShape, anHyp);
else if (!_father->IsUsedHypothesis( anHyp, this ))
algo = GetAlgo();
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))// ignore hyp status
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else if ( algo->IsStatusFatal( aux_ret )) {
meshDS->RemoveHypothesis(_subShape, anHyp);
ret = aux_ret;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
break;
}
case REMOVE_HYP:
algo = GetAlgo();
if (algo == NULL) // no more algo applying on sub-shape...
{
- SetAlgoState(NO_ALGO);
+ setAlgoState(NO_ALGO);
}
else
{
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
algo = GetAlgo();
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
break;
}
case ADD_FATHER_ALGO: { // new father algo
ASSERT( algo );
if ( algo == anHyp ) {
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
algo = GetAlgo();
if (algo == NULL) // no more applying algo on father
{
- SetAlgoState(NO_ALGO);
+ setAlgoState(NO_ALGO);
}
else
{
if ( algo->CheckHypothesis((*_father),_subShape , aux_ret ))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
modifiedHyp = true;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
break;
}
case REMOVE_HYP: {
algo = GetAlgo();
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret ))
- SetAlgoState(HYP_OK);
+ setAlgoState(HYP_OK);
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
modifiedHyp = true;
break;
}
algo = GetAlgo();
if (algo == NULL) // no more algo applying on sub-shape...
{
- SetAlgoState(NO_ALGO);
+ setAlgoState(NO_ALGO);
}
else
{
modifiedHyp = true;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
modifiedHyp = true;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
break;
}
case ADD_FATHER_ALGO: {
modifiedHyp = true;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
ASSERT(algo);
if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) {
// is there the same local hyp or maybe a new father algo applied?
- if ( !GetSimilarAttached( _subShape, anHyp ) )
+ if ( !getSimilarAttached( _subShape, anHyp ) )
modifiedHyp = true;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
break;
}
case REMOVE_FATHER_ALGO: {
algo = GetAlgo();
if (algo == NULL) // no more applying algo on father
{
- SetAlgoState(NO_ALGO);
+ setAlgoState(NO_ALGO);
}
else
{
modifiedHyp = true;
}
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
}
if ( stateChange && _algoState == HYP_OK ) // hyp becomes OK
algo->SetEventListener( this );
- NotifyListenersOnEvent( event, ALGO_EVENT, anHyp );
+ notifyListenersOnEvent( event, ALGO_EVENT, anHyp );
if ( stateChange && oldAlgoState == HYP_OK ) { // hyp becomes KO
- DeleteOwnListeners();
+ deleteOwnListeners();
SetIsAlwaysComputed( false );
if (_subShape.ShapeType() == TopAbs_VERTEX ) {
// restore default states
if ( needFullClean ) {
// added or removed algo is all-dimensional
ComputeStateEngine( CLEAN );
- CleanDependsOn();
+ cleanDependsOn();
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
}
*/
//=============================================================================
-void SMESH_subMesh::SetAlgoState(int state)
+void SMESH_subMesh::setAlgoState(algo_state state)
{
_algoState = state;
}
*/
//=============================================================================
-void SMESH_subMesh::CleanDependsOn()
+void SMESH_subMesh::cleanDependsOn()
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
bool SMESH_subMesh::ComputeStateEngine(int event)
{
- _computeError.reset();
+ switch ( event ) {
+ case MODIF_ALGO_STATE:
+ case COMPUTE:
+ //case COMPUTE_CANCELED:
+ case CLEAN:
+ //case SUBMESH_COMPUTED:
+ //case SUBMESH_RESTORED:
+ //case SUBMESH_LOADED:
+ //case MESH_ENTITY_REMOVED:
+ //case CHECK_COMPUTE_STATE:
+ _computeError.reset(); break;
+ default:;
+ }
//MESSAGE("SMESH_subMesh::ComputeStateEngine");
//SCRUTE(_computeState);
SMESHDS_SubMesh* smDS = GetSubMeshDS();
if ( smDS && smDS->NbNodes() ) {
if ( event == CLEAN ) {
- CleanDependants();
+ cleanDependants();
cleanSubMesh( this );
}
else
}
}
if ( event == MODIF_ALGO_STATE )
- CleanDependants();
+ cleanDependants();
return true;
}
SMESH_Gen *gen = _father->GetGen();
case MODIF_ALGO_STATE:
algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary())
- CleanDependsOn(); // clean sub-meshes with event CLEAN
+ cleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
break;
break;
#endif
case CLEAN:
- CleanDependants();
- RemoveSubMeshElementsAndNodes();
+ cleanDependants();
+ removeSubMeshElementsAndNodes();
break;
case SUBMESH_COMPUTED: // nothing to do
break;
break;
case MESH_ENTITY_REMOVED:
break;
+ case SUBMESH_LOADED:
+ loadDependentMeshes();
+ ComputeSubMeshStateEngine( SUBMESH_LOADED );
+ //break;
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
if (algo)
{
if (!algo->NeedDiscreteBoundary())
- CleanDependsOn(); // clean sub-meshes with event CLEAN
+ cleanDependsOn(); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
}
{
MESSAGE("***** verify compute state *****");
_computeState = NOT_READY;
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
break;
}
TopoDS_Shape shape = _subShape;
if (_father->HasShapeToMesh() ) {
bool subComputed = false;
if (!algo->OnlyUnaryInput())
- shape = GetCollection( gen, algo, subComputed );
+ shape = getCollection( gen, algo, subComputed );
else
- subComputed = SubMeshesComputed();
+ subComputed = subMeshesComputed();
ret = ( algo->NeedDiscreteBoundary() ? subComputed :
algo->SupportSubmeshes() ? true :
( !subComputed || _father->IsNotConformAllowed() ));
break;
}
}
- // compute
-// CleanDependants(); for "UseExisting_*D" algos
-// RemoveSubMeshElementsAndNodes();
+ // Compute
+
+ //cleanDependants(); for "UseExisting_*D" algos
+ //removeSubMeshElementsAndNodes();
+ loadDependentMeshes();
ret = false;
_computeState = FAILED_TO_COMPUTE;
_computeError = SMESH_ComputeError::New(COMPERR_OK,"",algo);
}
}
catch ( SALOME_Exception& S_ex ) {
+ const int skipSalomeShift = 7; /* to skip "Salome " of
+ "Salome Exception" prefix returned
+ by SALOME_Exception::what() */
if ( !_computeError ) _computeError = SMESH_ComputeError::New();
_computeError->myName = COMPERR_SLM_EXCEPTION;
- _computeError->myComment = S_ex.what();
+ _computeError->myComment = S_ex.what() + skipSalomeShift;
}
catch ( std::exception& exc ) {
if ( !_computeError ) _computeError = SMESH_ComputeError::New();
else
ret = false;
}
+ // check if an error reported on any sub-shape
+ bool isComputeErrorSet = !checkComputeError( algo, ret, shape );
+ // check if anything was built
TopExp_Explorer subS(shape, _subShape.ShapeType());
- if (ret) // check if anything was built
+ if (ret)
{
for (; ret && subS.More(); subS.Next())
ret = _father->GetSubMesh( subS.Current() )->IsMeshComputed();
}
- bool isComputeErrorSet = !CheckComputeError( algo, shape );
+ // Set _computeError
if (!ret && !isComputeErrorSet)
{
- // Set _computeError
for (subS.ReInit(); subS.More(); subS.Next())
{
SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
{
_computeError.reset();
}
- UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
+
+ // send event SUBMESH_COMPUTED
+ if ( ret ) {
+ if ( !algo->NeedDiscreteBoundary() )
+ // send SUBMESH_COMPUTED to dependants of all sub-meshes of shape
+ for (subS.ReInit(); subS.More(); subS.Next())
+ {
+ SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
+ SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(false,false);
+ while ( smIt->more() ) {
+ sm = smIt->next();
+ if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX )
+ sm->updateDependantsState( SUBMESH_COMPUTED );
+ else
+ break;
+ }
+ }
+ else
+ updateDependantsState( SUBMESH_COMPUTED );
+ }
}
break;
#ifdef WITH_SMESH_CANCEL_COMPUTE
break;
#endif
case CLEAN:
- CleanDependants();
- RemoveSubMeshElementsAndNodes();
+ cleanDependants();
+ removeSubMeshElementsAndNodes();
_computeState = NOT_READY;
algo = GetAlgo();
if (algo)
if (ret)
_computeState = READY_TO_COMPUTE;
else
- SetAlgoState(MISSING_HYP);
+ setAlgoState(MISSING_HYP);
}
break;
case SUBMESH_COMPUTED: // nothing to do
break;
case MESH_ENTITY_REMOVED:
break;
+ case SUBMESH_LOADED:
+ loadDependentMeshes();
+ ComputeSubMeshStateEngine( SUBMESH_LOADED );
+ //break;
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
ComputeStateEngine( CLEAN );
algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary())
- CleanDependsOn(); // clean sub-meshes with event CLEAN
+ cleanDependsOn(); // clean sub-meshes with event CLEAN
break;
case COMPUTE: // nothing to do
break;
break;
#endif
case CLEAN:
- CleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN
- RemoveSubMeshElementsAndNodes();
+ cleanDependants(); // clean sub-meshes, dependant on this one, with event CLEAN
+ removeSubMeshElementsAndNodes();
_computeState = NOT_READY;
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
if (algo) algo->SubmeshRestored( this );
break;
case MESH_ENTITY_REMOVED:
- UpdateDependantsState( CHECK_COMPUTE_STATE );
- ComputeStateEngine( CHECK_COMPUTE_STATE );
+ updateDependantsState ( CHECK_COMPUTE_STATE );
+ ComputeStateEngine ( CHECK_COMPUTE_STATE );
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
break;
case CHECK_COMPUTE_STATE:
_computeState = NOT_READY;
}
break;
+ case SUBMESH_LOADED:
+ // already treated event, thanks to which _computeState == COMPUTE_OK
+ break;
default:
ASSERT(0);
break;
ComputeStateEngine( CLEAN );
algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary())
- CleanDependsOn(); // clean sub-meshes with event CLEAN
+ cleanDependsOn(); // clean sub-meshes with event CLEAN
if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE;
else
break;
case COMPUTE: // nothing to do
break;
-#ifdef WITH_SMESH_CANCEL_COMPUTE
case COMPUTE_CANCELED:
{
algo = GetAlgo();
algo->CancelCompute();
}
break;
-#endif
case CLEAN:
- CleanDependants(); // submeshes dependent on me should be cleaned as well
- RemoveSubMeshElementsAndNodes();
+ cleanDependants(); // submeshes dependent on me should be cleaned as well
+ removeSubMeshElementsAndNodes();
break;
case SUBMESH_COMPUTED: // allow retry compute
if (_algoState == HYP_OK)
else
_computeState = NOT_READY;
break;
+ // case SUBMESH_LOADED:
+ // break;
default:
ASSERT(0);
break;
break;
}
- NotifyListenersOnEvent( event, COMPUTE_EVENT );
+ notifyListenersOnEvent( event, COMPUTE_EVENT );
return ret;
}
*/
//=======================================================================
-bool SMESH_subMesh::CheckComputeError(SMESH_Algo* theAlgo, const TopoDS_Shape& theShape)
+bool SMESH_subMesh::checkComputeError(SMESH_Algo* theAlgo,
+ const bool theComputeOK,
+ const TopoDS_Shape& theShape)
{
bool noErrors = true;
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
- if ( !smIt->next()->CheckComputeError( theAlgo ))
+ if ( !smIt->next()->checkComputeError( theAlgo, theComputeOK ))
noErrors = false;
}
for (TopoDS_Iterator subIt( theShape ); subIt.More(); subIt.Next()) {
SMESH_subMesh* sm = _father->GetSubMesh( subIt.Value() );
if ( sm != this ) {
- if ( !sm->CheckComputeError( theAlgo, sm->GetSubShape() ))
+ if ( !sm->checkComputeError( theAlgo, theComputeOK, sm->GetSubShape() ))
noErrors = false;
- UpdateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
+ updateDependantsState( SUBMESH_COMPUTED ); // send event SUBMESH_COMPUTED
}
}
}
}
{
- // Check my state
+
+ // Set my _computeState
+
if ( !_computeError || _computeError->IsOK() )
{
// no error description is set to this sub-mesh, check if any mesh is computed
_computeState = IsMeshComputed() ? COMPUTE_OK : FAILED_TO_COMPUTE;
+ if ( _computeState != COMPUTE_OK )
+ {
+ if ( _subShape.ShapeType() == TopAbs_EDGE &&
+ BRep_Tool::Degenerated( TopoDS::Edge( _subShape )) )
+ _computeState = COMPUTE_OK;
+ else if ( theComputeOK )
+ _computeError = SMESH_ComputeError::New(COMPERR_NO_MESH_ON_SHAPE,"",theAlgo);
+ }
}
- else
+
+ if ( _computeError && !_computeError->IsOK() )
{
if ( !_computeError->myAlgo )
_computeError->myAlgo = theAlgo;
}
//=======================================================================
-//function : UpdateSubMeshState
+//function : updateSubMeshState
//purpose :
//=======================================================================
-void SMESH_subMesh::UpdateSubMeshState(const compute_state theState)
+void SMESH_subMesh::updateSubMeshState(const compute_state theState)
{
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
while ( smIt->more() )
//purpose :
//=======================================================================
-void SMESH_subMesh::ComputeSubMeshStateEngine(int event)
+void SMESH_subMesh::ComputeSubMeshStateEngine(int event, const bool includeSelf)
{
- SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
+ SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(includeSelf,false);
while ( smIt->more() )
smIt->next()->ComputeStateEngine(event);
}
//=======================================================================
-//function : UpdateDependantsState
+//function : updateDependantsState
//purpose :
//=======================================================================
-void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent)
+void SMESH_subMesh::updateDependantsState(const compute_event theEvent)
{
- //MESSAGE("SMESH_subMesh::UpdateDependantsState");
TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
for (; it.More(); it.Next())
{
const TopoDS_Shape& ancestor = it.Value();
- SMESH_subMesh *aSubMesh =
- _father->GetSubMeshContaining(ancestor);
- if (aSubMesh)
+ if ( SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor))
aSubMesh->ComputeStateEngine( theEvent );
}
}
*/
//=============================================================================
-void SMESH_subMesh::CleanDependants()
+void SMESH_subMesh::cleanDependants()
{
int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1;
*/
//=============================================================================
-void SMESH_subMesh::RemoveSubMeshElementsAndNodes()
+void SMESH_subMesh::removeSubMeshElementsAndNodes()
{
- //SCRUTE(_subShape.ShapeType());
-
cleanSubMesh( this );
// algo may bind a submesh not to _subShape, eg 3D algo
}
//=======================================================================
-//function : GetCollection
+//function : getCollection
//purpose : return a shape containing all sub-shapes of the MainShape that can be
// meshed at once along with _subShape
//=======================================================================
-TopoDS_Shape SMESH_subMesh::GetCollection(SMESH_Gen * theGen,
+TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
SMESH_Algo* theAlgo,
bool & theSubComputed)
{
- MESSAGE("SMESH_subMesh::GetCollection");
-
- theSubComputed = SubMeshesComputed();
+ theSubComputed = subMeshesComputed();
TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();
if (strcmp( anAlgo->GetName(), theAlgo->GetName()) == 0 && // same algo
anAlgo->GetUsedHypothesis( *_father, S, ignoreAuxiliaryHyps ) == aUsedHyp) // same hyps
aBuilder.Add( aCompound, S );
- if ( !subMesh->SubMeshesComputed() )
+ if ( !subMesh->subMeshesComputed() )
theSubComputed = false;
}
}
}
//=======================================================================
-//function : GetSimilarAttached
+//function : getSimilarAttached
//purpose : return a hypothesis attached to theShape.
// If theHyp is provided, similar but not same hypotheses
// is returned; else only applicable ones having theHypType
// is returned
//=======================================================================
-const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape& theShape,
+const SMESH_Hypothesis* SMESH_subMesh::getSimilarAttached(const TopoDS_Shape& theShape,
const SMESH_Hypothesis * theHyp,
const int theHypType)
{
MESSAGE ("SMESH_subMesh::CheckConcurentHypothesis");
// is there local hypothesis on me?
- if ( GetSimilarAttached( _subShape, 0, theHypType ) )
+ if ( getSimilarAttached( _subShape, 0, theHypType ) )
return SMESH_Hypothesis::HYP_OK;
for (; it.More(); it.Next())
{
const TopoDS_Shape& ancestor = it.Value();
- const SMESH_Hypothesis* hyp = GetSimilarAttached( ancestor, 0, theHypType );
+ const SMESH_Hypothesis* hyp = getSimilarAttached( ancestor, 0, theHypType );
if ( hyp )
{
if ( aPrevWithHyp.IsNull() || aPrevWithHyp.IsSame( ancestor ))
SMESH_subMesh* where)
{
if ( listener && where ) {
- where->SetEventListener( listener, data );
- myOwnListeners.push_back( OwnListenerData( where, listener ));
+ where->setEventListener( listener, data );
+ _ownListeners.push_back( OwnListenerData( where, listener ));
}
}
*/
//================================================================================
-void SMESH_subMesh::SetEventListener(EventListener* listener, EventListenerData* data)
+void SMESH_subMesh::setEventListener(EventListener* listener,
+ EventListenerData* data)
{
map< EventListener*, EventListenerData* >::iterator l_d =
- myEventListeners.find( listener );
- if ( l_d != myEventListeners.end() ) {
+ _eventListeners.find( listener );
+ if ( l_d != _eventListeners.end() ) {
EventListenerData* curData = l_d->second;
if ( curData && curData != data && curData->IsDeletable() )
delete curData;
l_d->second = data;
}
- else
- myEventListeners.insert( make_pair( listener, data ));
+ else
+ {
+ for ( l_d = _eventListeners.begin(); l_d != _eventListeners.end(); ++l_d )
+ if ( listener->GetName() == l_d->first->GetName() )
+ {
+ EventListenerData* curData = l_d->second;
+ if ( curData && curData != data && curData->IsDeletable() )
+ delete curData;
+ if ( l_d->first->IsDeletable() )
+ delete l_d->first;
+ _eventListeners.erase( l_d );
+ break;
+ }
+ _eventListeners.insert( make_pair( listener, data ));
+ }
}
//================================================================================
EventListenerData* SMESH_subMesh::GetEventListenerData(EventListener* listener) const
{
map< EventListener*, EventListenerData* >::const_iterator l_d =
- myEventListeners.find( listener );
- if ( l_d != myEventListeners.end() )
+ _eventListeners.find( listener );
+ if ( l_d != _eventListeners.end() )
return l_d->second;
return 0;
}
+//================================================================================
+/*!
+ * \brief Return an event listener data
+ * \param listenerName - the listener name
+ * \retval EventListenerData* - found data, maybe NULL
+ */
+//================================================================================
+
+EventListenerData* SMESH_subMesh::GetEventListenerData(const string& listenerName) const
+{
+ map< EventListener*, EventListenerData* >::const_iterator l_d = _eventListeners.begin();
+ for ( ; l_d != _eventListeners.end(); ++l_d )
+ if ( listenerName == l_d->first->GetName() )
+ return l_d->second;
+ return 0;
+}
+
//================================================================================
/*!
* \brief Notify stored event listeners on the occured event
*/
//================================================================================
-void SMESH_subMesh::NotifyListenersOnEvent( const int event,
+void SMESH_subMesh::notifyListenersOnEvent( const int event,
const event_type eventType,
SMESH_Hypothesis* hyp)
{
- map< EventListener*, EventListenerData* >::iterator l_d = myEventListeners.begin();
- for ( ; l_d != myEventListeners.end(); ++l_d )
+ map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
+ for ( ; l_d != _eventListeners.end(); )
{
- std::pair< EventListener*, EventListenerData* > li_da = *l_d; /* copy to enable removal
- of a listener from
- myEventListeners by
- its ProcessEvent() */
+ std::pair< EventListener*, EventListenerData* > li_da = *l_d++; /* copy to enable removal
+ of a listener from
+ _eventListeners by
+ its ProcessEvent() */
if ( li_da.first->myBusySM.insert( this ).second )
{
+ const size_t nbListenersBefore = _eventListeners.size();
li_da.first->ProcessEvent( event, eventType, this, li_da.second, hyp );
- li_da.first->myBusySM.erase( this );
+ if ( nbListenersBefore == _eventListeners.size() )
+ li_da.first->myBusySM.erase( this ); // a listener hopefully not removed
}
}
}
void SMESH_subMesh::DeleteEventListener(EventListener* listener)
{
map< EventListener*, EventListenerData* >::iterator l_d =
- myEventListeners.find( listener );
- if ( l_d != myEventListeners.end() ) {
- if ( l_d->first && l_d->first->IsDeletable() ) delete l_d->first;
- if ( l_d->second && l_d->second->IsDeletable() ) delete l_d->second;
- myEventListeners.erase( l_d );
+ _eventListeners.find( listener );
+ if ( l_d != _eventListeners.end() && l_d->first )
+ {
+ if ( l_d->second && l_d->second->IsDeletable() )
+ {
+ delete l_d->second;
+ }
+ l_d->first->myBusySM.erase( this );
+ if ( l_d->first->IsDeletable() )
+ {
+ l_d->first->BeforeDelete( this, l_d->second );
+ delete l_d->first;
+ }
+ _eventListeners.erase( l_d );
}
}
*/
//================================================================================
-void SMESH_subMesh::DeleteOwnListeners()
+void SMESH_subMesh::deleteOwnListeners()
{
list< OwnListenerData >::iterator d;
- for ( d = myOwnListeners.begin(); d != myOwnListeners.end(); ++d )
+ for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
{
if ( !_father->MeshExists( d->myMeshID ))
continue;
continue;
d->mySubMesh->DeleteEventListener( d->myListener );
}
- myOwnListeners.clear();
+ _ownListeners.clear();
+}
+
+//=======================================================================
+//function : loadDependentMeshes
+//purpose : loads dependent meshes on SUBMESH_LOADED event
+//=======================================================================
+
+void SMESH_subMesh::loadDependentMeshes()
+{
+ list< OwnListenerData >::iterator d;
+ for ( d = _ownListeners.begin(); d != _ownListeners.end(); ++d )
+ if ( _father != d->mySubMesh->_father )
+ d->mySubMesh->_father->Load();
+
+ // map< EventListener*, EventListenerData* >::iterator l_d = _eventListeners.begin();
+ // for ( ; l_d != _eventListeners.end(); ++l_d )
+ // if ( l_d->second )
+ // {
+ // const list<SMESH_subMesh*>& smList = l_d->second->mySubMeshes;
+ // list<SMESH_subMesh*>::const_iterator sm = smList.begin();
+ // for ( ; sm != smList.end(); ++sm )
+ // if ( _father != (*sm)->_father )
+ // (*sm)->_father->Load();
+ // }
}
//================================================================================