X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_MeshOp.cxx;h=cda44524c6dd34076ded1b724827e937350831c3;hp=ff98510088ead389874ccd87465f2a6b73ff0816;hb=537bc678633a5101ab915a4ee2d85187814a0fa8;hpb=03a1295ce9c17ecb847cab11f4e0c102a6bff6f4 diff --git a/src/SMESHGUI/SMESHGUI_MeshOp.cxx b/src/SMESHGUI/SMESHGUI_MeshOp.cxx index ff9851008..cda44524c 100644 --- a/src/SMESHGUI/SMESHGUI_MeshOp.cxx +++ b/src/SMESHGUI/SMESHGUI_MeshOp.cxx @@ -88,10 +88,10 @@ //================================================================================ SMESHGUI_MeshOp::SMESHGUI_MeshOp( const bool theToCreate, const bool theIsMesh ) : SMESHGUI_SelectionOp(), - myToCreate( theToCreate ), - myIsMesh( theIsMesh ), myDlg( 0 ), myShapeByMeshOp( 0 ), + myToCreate( theToCreate ), + myIsMesh( theIsMesh ), myHypoSet( 0 ) { if ( GeometryGUI::GetGeomGen()->_is_nil() )// check that GEOM_Gen exists @@ -206,11 +206,11 @@ void SMESHGUI_MeshOp::startOperation() for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) { connect( myDlg->tab( i ), SIGNAL( createHyp( const int, const int ) ), - this, SLOT( onCreateHyp( const int, const int ) ) ); + this, SLOT( onCreateHyp( const int, const int ) ) ); connect( myDlg->tab( i ), SIGNAL( editHyp( const int, const int ) ), - this, SLOT( onEditHyp( const int, const int ) ) ); + this, SLOT( onEditHyp( const int, const int ) ) ); connect( myDlg->tab( i ), SIGNAL( selectAlgo( const int ) ), - this, SLOT( onAlgoSelected( const int ) ) ); + this, SLOT( onAlgoSelected( const int ) ) ); } connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& ))); connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool ))); @@ -576,7 +576,7 @@ void SMESHGUI_MeshOp::selectionDone() if (aSeq->length() > 0) { shapeDim = -1; - for (int iss = 0; iss < aSeq->length() && shapeDim < 3; iss++) { + for ( CORBA::ULong iss = 0; iss < aSeq->length() && shapeDim < 3; iss++) { GEOM::GEOM_Object_var aGeomVar = aSeq[iss]; switch ( aGeomVar->GetShapeType() ) { case GEOM::SOLID: shapeDim = 3; break; @@ -859,6 +859,60 @@ static bool isCompatible(const HypothesisData* theAlgoData, return ( SMESH::IsAvailableHypothesis( theAlgoData, theHypData->TypeName, isOptional )); } +//================================================================================ +/*! + * \brief check compatibility of the geometry + * \param theAlgoData - to select hypos able to be used by this algo + * \param theCurrentGeomToSelect - the current name of the selected geometry + * \param theGeomVar - currently selected geometry + * \retval bool - check result + */ +//================================================================================ +bool SMESHGUI_MeshOp::isCompatibleToGeometry(HypothesisData* theAlgoData, + QString theCurrentGeomToSelect, + GEOM::GEOM_Object_var theGeomVar) +{ + if ( theGeomVar->_is_nil() ) + return true; + + bool isApplicable = false; + if ( theCurrentGeomToSelect == myLastGeomToSelect && !theCurrentGeomToSelect.isEmpty() ) { + THypLabelIsAppMap::const_iterator iter = myHypMapIsApplicable.find( theAlgoData->Label ); + if ( iter != myHypMapIsApplicable.end() && iter.key() == theAlgoData->Label ) { + isApplicable = iter.value(); + return isApplicable; + } + } + bool toCheckIsApplicableToAll = !myIsMesh; + if ( toCheckIsApplicableToAll ) + toCheckIsApplicableToAll = ( theGeomVar->GetType() == GEOM_GROUP ); + isApplicable = SMESH::IsApplicable( theAlgoData->TypeName, theGeomVar, toCheckIsApplicableToAll ); + myHypMapIsApplicable.insert( theAlgoData->Label, isApplicable ); + return isApplicable; +} + +//================================================================================ +/*! + * \brief check compatibility of the mesh type + * \param theAlgoData - to select hypos able to be used by this algo + * \param theMeshType - type of mesh for filtering algorithms + * \retval bool - check result + */ +//================================================================================ +bool SMESHGUI_MeshOp::isCompatibleToMeshType(HypothesisData* theAlgoData, + QString theMeshType) +{ + bool isAvailableAlgo = ( theAlgoData->OutputTypes.count() == 0 ); + QStringList::const_iterator inElemType = theAlgoData->OutputTypes.begin(); + for ( ; inElemType != theAlgoData->OutputTypes.end(); inElemType++ ) { + if ( *inElemType == theMeshType ) { + isAvailableAlgo = true; + break; + } + } + return isAvailableAlgo; +} + //================================================================================ /*! * \brief Gets available hypotheses or algorithms @@ -866,7 +920,9 @@ static bool isCompatible(const HypothesisData* theAlgoData, * \param theHypType - specifies whether algorims or hypotheses or additional ones * are retrieved (possible values are in HypType enumeration) * \param theHyps - Output list of hypotheses' names - * \param theAlgoData - to select hypos able to be used by this algo (optional) + * \param thePrevAlgoData - to select hypos able to be used by previously algo (optional) + * \param theNextAlgoData - to select hypos able to be used by next algo (optional) + * \param theMeshType - type of mesh for filtering algorithms (optional) * * Gets available hypotheses or algorithm in accordance with input parameters */ @@ -875,7 +931,9 @@ void SMESHGUI_MeshOp::availableHyps( const int theDim, const int theHypType, QStringList& theHyps, THypDataList& theDataList, - HypothesisData* theAlgoData ) const + HypothesisData* thePrevAlgoData, + HypothesisData* theNextAlgoData, + const QString& theMeshType) { theDataList.clear(); theHyps.clear(); @@ -884,14 +942,35 @@ void SMESHGUI_MeshOp::availableHyps( const int theDim, QStringList aHypTypeNameList = SMESH::GetAvailableHypotheses( isAlgo, theDim, isAux, myIsOnGeometry, !myIsMesh ); QStringList::const_iterator anIter; + GEOM::GEOM_Object_var aGeomVar; + QString aCurrentGeomToSelect; + if ( !theMeshType.isEmpty() ) { + aCurrentGeomToSelect = myDlg->selectedObject( myToCreate ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Obj ); + if ( _PTR(SObject) so = studyDS()->FindObjectID( aCurrentGeomToSelect.toLatin1().data() )) { + aGeomVar = SMESH::GetGeom( so ); + } + if ( aCurrentGeomToSelect != myLastGeomToSelect ) + myHypMapIsApplicable.clear(); + } + for ( anIter = aHypTypeNameList.begin(); anIter != aHypTypeNameList.end(); ++anIter ) { HypothesisData* aData = SMESH::GetHypothesisData( *anIter ); - if ( isCompatible ( theAlgoData, aData, theHypType )) { + if ( ( isCompatible ( thePrevAlgoData, aData, theHypType ) && + isCompatible ( theNextAlgoData, aData, theHypType ) ) || + ( theMeshType == "ANY" && aData->InputTypes.isEmpty())) { + if ( !theMeshType.isEmpty() && theDim >= SMESH::DIM_2D && + ( ( theMeshType != "ANY" && !isCompatibleToMeshType( aData, theMeshType )) || + !isCompatibleToGeometry( aData, aCurrentGeomToSelect, aGeomVar ))) + continue; theDataList.append( aData ); theHyps.append( aData->Label ); } } + + if ( !theMeshType.isEmpty() && !aCurrentGeomToSelect.isEmpty() && + myLastGeomToSelect != aCurrentGeomToSelect ) + myLastGeomToSelect = aCurrentGeomToSelect; } //================================================================================ @@ -1421,42 +1500,32 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, // check that tab enabled of one less dimension if ( aDim > SMESH::DIM_0D ) { - if ( isAccessibleDim( aDim - 1 ) ) - { - if (( myDlg->currentMeshType() != MT_ANY ) && - ( !algoData || ( myIsOnGeometry && algoData->InputTypes.isEmpty() ))) - for (int i = aDim - 1; i >= SMESH::DIM_0D; i--) - if ( isAccessibleDim( i ) ) { + if ( myIsOnGeometry ) { + QString anCompareType = currentMeshTypeName(myDlg->currentMeshType()); + bool is2dtype = ( anCompareType == "QUAD" ) || ( anCompareType == "TRIA" ); + int dim = is2dtype ? SMESH::DIM_2D : SMESH::DIM_3D; + for (int i = dim; i >= SMESH::DIM_0D; i--) { + if ( i != aDim ) { + if ( algoData && algoData->InputTypes.isEmpty() ) { myDlg->disableTab( i ); setCurrentHyp(i, Algo, -1); } - } - else if ( algoData && myIsOnGeometry && !algoData->InputTypes.isEmpty() ) - { - myDlg->enableTab( aDim - 1 ); - } - } - - // check that algorithms of other dimentions are compatible with - // the selected one - if ( !algoData ) { // all algos becomes available - if (myDlg->currentMeshType() == MT_ANY || aDim == SMESH::DIM_1D || aDim == SMESH::DIM_0D) - availableHyps( aDim, Algo, anAvailable, myAvailableHypData[ aDim ][ Algo ]); - else{ - anAvailable.clear(); - for (int i = 0; i < myFilteredAlgoData[aDim].count(); ++i) { - HypothesisData* aCurAlgo = myFilteredAlgoData[aDim][ i ]; - anAvailable.append( aCurAlgo->Label ); + else { + myDlg->enableTab( i ); + } + } } } - myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable ); } + + int algoDim = aDim; + HypothesisData* a3DAlgo = 0; // 2 loops: backward and forward from algo dimension - for ( int forward = false; forward <= true; ++forward ) + for ( int forward = 0; forward <= 1; ++forward ) { - int dim = aDim + 1, lastDim = SMESH::DIM_3D, dir = 1; + int dim = algoDim + 1, lastDim = SMESH::DIM_3D, dir = 1; if ( !forward ) { - dim = aDim - 1; lastDim = SMESH::DIM_0D; dir = -1; + dim = algoDim - 1; lastDim = SMESH::DIM_0D; dir = -1; } HypothesisData* prevAlgo = algoData; bool noCompatible = false; @@ -1471,57 +1540,47 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, algoByDim[ dim ] = 0; continue; } + HypothesisData* nextAlgo = 0; + if ( myMaxShapeDim == SMESH::DIM_3D && a3DAlgo && dim == SMESH::DIM_2D ) { + nextAlgo = a3DAlgo; + } // get currently selected algo int algoIndex = currentHyp( dim, Algo ); HypothesisData* curAlgo = hypData( dim, Algo, algoIndex ); - if ( curAlgo ) { // some algo selected - if ( !isCompatible( prevAlgo, curAlgo, Algo )) - curAlgo = 0; + + QString anCompareType = currentMeshTypeName(myDlg->currentMeshType()); + QString anCurrentCompareType = ""; + if ( dim == SMESH::DIM_3D || anCompareType == "ANY" ) + anCurrentCompareType = anCompareType; + else if ( dim == SMESH::DIM_2D ) { + anCurrentCompareType = (anCompareType == "HEXA" || anCompareType == "QUAD") ? "QUAD" : "TRIA"; + nextAlgo = 0; } + // set new available algoritms - if (myDlg->currentMeshType() == MT_ANY || dim == SMESH::DIM_1D || dim == SMESH::DIM_0D) - availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo ); - else{ - anAvailable.clear(); - myAvailableHypData[dim][Algo].clear(); - for (int i = 0; i < myFilteredAlgoData[dim].count(); ++i) { - HypothesisData* aCurAlgo = myFilteredAlgoData[dim][ i ]; - if ( isCompatible ( prevAlgo, aCurAlgo, Algo )) { - anAvailable.append( aCurAlgo->Label ); - myAvailableHypData[dim][Algo].append( aCurAlgo ); - } - } - } + availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo, nextAlgo, anCurrentCompareType); HypothesisData* soleCompatible = 0; if ( anAvailable.count() == 1 ) soleCompatible = myAvailableHypData[dim][Algo][0]; - if ( dim == aTopDim && prevAlgo ) {// all available algoritms should be selectable any way - if (aTopDim == SMESH::DIM_2D) { - anAvailable.clear(); - for (int i = 0; i < myFilteredAlgoData[dim].count(); ++i) { - HypothesisData* aCurAlgo = myFilteredAlgoData[dim][ i ]; - anAvailable.append( aCurAlgo->Label ); - } - } - if (aTopDim == SMESH::DIM_3D) - availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], 0 ); - } myDlg->tab( dim )->setAvailableHyps( Algo, anAvailable ); noCompatible = anAvailable.isEmpty(); - - // restore previously selected algo - if (dim == aTopDim && prevAlgo && aTopDim == SMESH::DIM_2D) - algoIndex = myFilteredAlgoData[dim].indexOf( curAlgo ); - else - algoIndex = myAvailableHypData[dim][Algo].indexOf( curAlgo ); - if ( !isSubmesh && algoIndex < 0 && soleCompatible && !forward && dim != SMESH::DIM_0D) + algoIndex = myAvailableHypData[dim][Algo].indexOf( curAlgo ); + if ( !isSubmesh && algoIndex < 0 && soleCompatible && !forward && dim != SMESH::DIM_0D) { // select the sole compatible algo algoIndex = myAvailableHypData[dim][Algo].indexOf( soleCompatible ); + } setCurrentHyp( dim, Algo, algoIndex); // remember current algo prevAlgo = algoByDim[ dim ] = hypData( dim, Algo, algoIndex ); } + if ( myMaxShapeDim == SMESH::DIM_3D && forward && algoDim == SMESH::DIM_1D ) + { + algoDim = SMESH::DIM_3D; + forward = -1; + a3DAlgo = prevAlgo; + continue; + } } // set hypotheses corresponding to the found algoritms @@ -1563,7 +1622,7 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, myObjHyps[ dim ][ type ].count() > 0 && curHypType == SMESH::toQStr( myObjHyps[ dim ][ type ].first().first->GetName()) ) { - HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() ); + HypothesisData* hypData = SMESH::GetHypothesisData( SMESH::toQStr( curHyp->GetName() )); for (int i = 0; i < myAvailableHypData[ dim ][ Algo ].count(); ++i) { curAlgo = myAvailableHypData[ dim ][ Algo ][ i ]; if (curAlgo && hypData && isCompatible(curAlgo, hypData, type)) @@ -1579,7 +1638,7 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex, { // check if a selected hyp is compatible with the curAlgo if ( !curHyp->_is_nil() ) { - HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() ); + HypothesisData* hypData = SMESH::GetHypothesisData( SMESH::toQStr( curHyp->GetName() )); if ( !isCompatible( curAlgo, hypData, type )) curHyp = SMESH::SMESH_Hypothesis::_nil(); } @@ -2172,7 +2231,7 @@ void SMESHGUI_MeshOp::readMesh() if ( myObjHyps[ dim ][ Algo ].count() > 0 ) { SMESH::SMESH_Hypothesis_var aVar = myObjHyps[ dim ][ Algo ].first().first; - HypothesisData* algoData = SMESH::GetHypothesisData( aVar->GetName() ); + HypothesisData* algoData = SMESH::GetHypothesisData( SMESH::toQStr( aVar->GetName() )); aHypIndex = myAvailableHypData[ dim ][ Algo ].indexOf ( algoData ); // if ( aHypIndex < 0 && algoData ) { // // assigned algo is incompatible with other algorithms @@ -2195,6 +2254,9 @@ void SMESHGUI_MeshOp::readMesh() { // get hypotheses existingHyps( dim, hypType, pObj, anExisting, myObjHyps[ dim ][ hypType ] ); + if ( myObjHyps[ dim ][ hypType ].count() == 0 ) { + setCurrentHyp( dim, hypType, -1 ); + } for ( int i = 0, nb = myObjHyps[ dim ][ hypType ].count(); i < nb; ++i ) { // find index of required hypothesis among existing ones for this dimension and type @@ -2310,12 +2372,12 @@ bool SMESHGUI_MeshOp::editMeshOrSubMesh( QString& theMess ) // First, remove old algos in order to avoid messages on algorithm hiding for ( int dim = aDim; dim <= SMESH::DIM_3D; dim++ ) { - if ( isAccessibleDim( dim ) && myObjHyps[ dim ][ Algo ].count() > 0 ) + if ( /*isAccessibleDim( dim ) &&*/ myObjHyps[ dim ][ Algo ].count() > 0 ) { SMESH::SMESH_Hypothesis_var anOldAlgo = myObjHyps[ dim ][ Algo ].first().first; SMESH::SMESH_Hypothesis_var anAlgoVar = getAlgo( dim ); if ( anAlgoVar->_is_nil() || // no new algo selected or - strcmp(anOldAlgo->GetName(), anAlgoVar->GetName()) ) // algo change + SMESH::toQStr(anOldAlgo->GetName()) != SMESH::toQStr(anAlgoVar->GetName())) // algo change { // remove old algorithm SMESH::RemoveHypothesisOrAlgorithmOnMesh ( pObj, myObjHyps[ dim ][ Algo ].first().first ); @@ -2598,100 +2660,46 @@ void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theI * \param theIndex - Index of current type of mesh */ //================================================================================ -void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theIndex) +void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theIndex ) { - int aDim; - THypDataList anAvailableAlgsData; QStringList anAvailableAlgs; - QString anCompareType = ""; - bool isAvailableChoiceAlgo = false; - int anCurrentAvailableAlgo = 0; + QString anCompareType = currentMeshTypeName( theIndex ); + int anCurrentAvailableAlgo = -1; bool isNone = true; - switch ( theIndex ) { - case MT_ANY: - anCompareType = "ANY"; - aDim = SMESH::DIM_3D; - break; - case MT_TRIANGULAR: + int aDim = SMESH::DIM_3D; + if ( theIndex == MT_TRIANGULAR || theIndex == MT_QUADRILATERAL) aDim = SMESH::DIM_2D; - anCompareType = "TRIA"; - break; - case MT_QUADRILATERAL: - aDim = SMESH::DIM_2D; - anCompareType = "QUAD"; - break; - case MT_TETRAHEDRAL: - aDim = SMESH::DIM_3D; - anCompareType = "TETRA"; - break; - case MT_HEXAHEDRAL: - aDim = SMESH::DIM_3D; - anCompareType = "HEXA"; - break; - default:; - } - - bool toCheckIsApplicableToAll = !myIsMesh; - GEOM::GEOM_Object_var aGeomVar; - QString anEntry = - myDlg->selectedObject( myToCreate ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Obj ); - if ( _PTR(SObject) so = studyDS()->FindObjectID( anEntry.toLatin1().data() )) - { - aGeomVar = SMESH::GetGeom( so ); - if ( !aGeomVar->_is_nil() && toCheckIsApplicableToAll ) - toCheckIsApplicableToAll = ( aGeomVar->GetType() == GEOM_GROUP ); - } - if ( anCompareType == "ANY" ) { + bool isReqDisBound = false; + int aReqDim = SMESH::DIM_3D; for ( int dim = SMESH::DIM_3D; dim >= SMESH::DIM_2D; dim-- ) { + anCurrentAvailableAlgo = -1; isNone = currentHyp( dim, Algo ) < 0; - isAvailableChoiceAlgo = false; - // retrieves a list of available algorithms from resources - availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData ); //return current algo in current tab and set new algorithm list - HypothesisData* algoCur; + HypothesisData* algoCur = 0; if ( !isNone && !myAvailableHypData[dim][Algo].empty() ) { algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) ); } - myAvailableHypData[dim][Algo].clear(); - myFilteredAlgoData[dim].clear(); - anAvailableAlgs.clear(); - if ( dim != SMESH::DIM_2D || currentHyp( SMESH::DIM_3D, Algo ) < 0 || - myAvailableHypData[SMESH::DIM_3D][Algo].empty() || - !myAvailableHypData[SMESH::DIM_3D][Algo].at( currentHyp( SMESH::DIM_3D, Algo ) )->InputTypes.isEmpty() ) - { - for (int i = 0 ; i < anAvailableAlgsData.count(); i++) - { - HypothesisData* curAlgo = anAvailableAlgsData.at(i); - if ( aGeomVar->_is_nil() || - SMESH::IsApplicable( curAlgo->TypeName, aGeomVar, toCheckIsApplicableToAll )) - { - anAvailableAlgs.append( curAlgo->Label ); - myAvailableHypData[dim][Algo].append( curAlgo ); - myFilteredAlgoData[dim].append( curAlgo ); - } - } - if ( !isNone && algoCur ) { - for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++) - { - HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i); - if ( algoAny->Label == algoCur->Label ){ - isAvailableChoiceAlgo = true; - anCurrentAvailableAlgo = i; - break; - } - } - } - else if ( !isNone ) { - isAvailableChoiceAlgo = true; - anCurrentAvailableAlgo = currentHyp( dim, Algo ); - } + HypothesisData* prevAlgo = 0; + HypothesisData* nextAlgo = 0; + if ( dim == SMESH::DIM_2D ) { + prevAlgo = hypData( SMESH::DIM_1D, Algo, currentHyp( SMESH::DIM_1D, Algo ) ); + if ( aDim == SMESH::DIM_3D ) + nextAlgo = hypData( SMESH::DIM_3D, Algo, currentHyp( SMESH::DIM_3D, Algo ) ); } + // retrieves a list of available algorithms from resources + availableHyps( dim, Algo, anAvailableAlgs, myAvailableHypData[dim][Algo], prevAlgo, nextAlgo, anCompareType); + anCurrentAvailableAlgo = myAvailableHypData[dim][Algo].indexOf( algoCur ); myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs ); - if ( isAvailableChoiceAlgo ) - setCurrentHyp( dim, Algo, anCurrentAvailableAlgo ); + setCurrentHyp( dim, Algo, anCurrentAvailableAlgo ); + if ( anCurrentAvailableAlgo > -1 ) + isReqDisBound = algoCur->InputTypes.isEmpty(); + if ( isReqDisBound ) { + aReqDim = dim; + break; + } } if ( !myIsOnGeometry ) for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) { @@ -2700,142 +2708,88 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI } else for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) { - if ( i > myMaxShapeDim ) myDlg->disableTab( i ); - else myDlg->enableTab( i ); + if ( i > myMaxShapeDim || ( isReqDisBound && i != aReqDim ) ) myDlg->disableTab( i ); + else myDlg->enableTab( i ); } myDlg->setCurrentTab( theTabIndex ); } else { - QString anCurrentAlgo; + HypothesisData* anCurrentAlgo; bool isReqDisBound = true; QString anCurrentCompareType = anCompareType; isNone = currentHyp( aDim, Algo ) < 0; - if ( !isNone && !myAvailableHypData[aDim][Algo].empty() && - myAvailableHypData[aDim][Algo].count() != anAvailableAlgsData.count() ) + if ( !isNone && !myAvailableHypData[aDim][Algo].empty() ) isReqDisBound = myAvailableHypData[aDim][Algo].at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty(); - else if ( !isNone ) - isReqDisBound = anAvailableAlgsData.at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty(); for ( int dim = aDim; dim >= SMESH::DIM_2D; dim-- ) { bool isNoneAlg = currentHyp( dim, Algo ) < 0; - isAvailableChoiceAlgo = false; - // retrieves a list of available algorithms from resources - availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData ); + anCurrentAvailableAlgo = -1; + HypothesisData* prevAlgo = 0; + HypothesisData* nextAlgo = 0; + if ( dim == SMESH::DIM_2D ) { + prevAlgo = hypData( SMESH::DIM_1D, Algo, currentHyp( SMESH::DIM_1D, Algo ) ); + if ( aDim == SMESH::DIM_3D ) + nextAlgo = hypData( SMESH::DIM_3D, Algo, currentHyp( SMESH::DIM_3D, Algo ) ); + } // finding algorithm which is selected - if ( !isNoneAlg && !myAvailableHypData[dim][Algo].empty() && - myAvailableHypData[dim][Algo].count() != anAvailableAlgsData.count() ) - anCurrentAlgo = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) )->Label; - else if ( !isNoneAlg ) - anCurrentAlgo = anAvailableAlgsData.at( currentHyp( dim, Algo ) )->Label; - anAvailableAlgs.clear(); - myAvailableHypData[dim][Algo].clear(); - myFilteredAlgoData[dim].clear(); - // finding and adding algorithm depending on the type mesh - for ( int i = 0 ; i < anAvailableAlgsData.count(); i++ ) - { - HypothesisData* algoIn = anAvailableAlgsData.at( i ); - bool isAvailableAlgo = ( algoIn->OutputTypes.count() == 0 ); - QStringList::const_iterator inElemType = algoIn->OutputTypes.begin(); - for ( ; inElemType != algoIn->OutputTypes.end(); inElemType++ ) - { - if ( *inElemType == anCurrentCompareType ) { - isAvailableAlgo = true; - break; - } - } - if ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ) { - if ( aGeomVar->_is_nil() || myMaxShapeDim != dim || - SMESH::IsApplicable( algoIn->TypeName, aGeomVar, toCheckIsApplicableToAll )) - { - anAvailableAlgs.append( algoIn->Label ); - myAvailableHypData[dim][Algo].append( algoIn ); - myFilteredAlgoData[dim].append( algoIn ); - } - } - //algorithm will be active, if the chosen algorithm available in the current mesh type - if ( !isNoneAlg && isAvailableAlgo && algoIn->Label == anCurrentAlgo ) { - isAvailableChoiceAlgo = true; - anCurrentAvailableAlgo = anAvailableAlgs.count() - 1 ; - } + if ( !isNoneAlg ) { + anCurrentAlgo = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) ); } + // retrieves a list of available algorithms from resources + availableHyps( dim, Algo, anAvailableAlgs, myAvailableHypData[dim][Algo], prevAlgo, nextAlgo, anCurrentCompareType ); + // finding and adding algorithm depending on the type mesh + anCurrentAvailableAlgo = myAvailableHypData[dim][Algo].indexOf( anCurrentAlgo ); //set new algorithm list and select the current algorithm myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs ); - anCurrentCompareType = ( anCompareType == "HEXA" ) ? "QUAD" : "TRIA"; - if ( isAvailableChoiceAlgo ) - setCurrentHyp( dim, Algo, anCurrentAvailableAlgo ); - else - setCurrentHyp( dim, Algo, -1 ); + anCurrentCompareType = ( anCompareType == "HEXA" || anCompareType == "QUAD" ) ? "QUAD" : "TRIA"; + setCurrentHyp( dim, Algo, anCurrentAvailableAlgo ); } - if ( isNone || isReqDisBound ) { - for ( int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++ ) { - if ( aDim != i ) { - myDlg->disableTab( i ); - setCurrentHyp(i, Algo, -1); - } - } + if ( aDim == SMESH::DIM_2D) { + myDlg->disableTab( SMESH::DIM_3D ); + setCurrentHyp( SMESH::DIM_3D, Algo, -1); } - else if ( !isNone ) { - if ( aDim == SMESH::DIM_2D){ - myDlg->disableTab( SMESH::DIM_3D ); - setCurrentHyp( SMESH::DIM_3D, Algo, -1); - } - for ( int i = myMaxShapeDim; i > SMESH::DIM_0D; i-- ) - { - isReqDisBound = ( currentHyp( i, Algo ) < 0 ) ? true : - myAvailableHypData[i][Algo].at( currentHyp( i, Algo ) )->InputTypes.isEmpty(); - if ( isReqDisBound ) { - for (int j = i - 1; j >= SMESH::DIM_0D; j--){ + for ( int i = myMaxShapeDim; i > SMESH::DIM_0D; i-- ) { + bool isNoneAlg = currentHyp( i, Algo ) < 0; + if ( !isNoneAlg ) + isReqDisBound = myAvailableHypData[i][Algo].at( currentHyp( i, Algo ) )->InputTypes.isEmpty(); + else + isReqDisBound = true; + if ( isReqDisBound && !isNoneAlg) { + for (int j = i; j >= SMESH::DIM_0D; j--) { + if ( currentHyp( j, Algo ) < 0 ) { myDlg->disableTab( j ); setCurrentHyp( j , Algo, -1 ); } - break; } + break; } } - myDlg->enableTab( aDim ); - myDlg->setCurrentTab( aDim ); + int currentTab = ( theTabIndex <= aDim ) ? theTabIndex : aDim; + myDlg->setCurrentTab( currentTab ); } + THypDataList anAvailableAlgsData; QStringList aHypothesesSetsList = SMESH::GetHypothesesSets( aDim ); QStringList aFilteredHypothesesSetsList; aFilteredHypothesesSetsList.clear(); QStringList::const_iterator inHypoSetName = aHypothesesSetsList.begin(); - for ( ; inHypoSetName != aHypothesesSetsList.end(); ++inHypoSetName ) - { + for ( ; inHypoSetName != aHypothesesSetsList.end(); ++inHypoSetName ) { HypothesesSet* currentHypoSet = SMESH::GetHypothesesSet( *inHypoSetName ); bool isAvailable = false; currentHypoSet->init( true ); - while ( currentHypoSet->next(), currentHypoSet->more() ) - { + while ( currentHypoSet->next(), currentHypoSet->more() ) { isAvailable = false; - if ( HypothesisData* algoDataIn = SMESH::GetHypothesisData( currentHypoSet->current() )) - { - for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++) - { - if ( myAvailableHypData[i][Algo].count() == 0 ) { - availableHyps( i, Algo, anAvailableAlgs, anAvailableAlgsData ); - for ( int j = 0 ; j < anAvailableAlgsData.count(); j++ ) - { - HypothesisData* aCurAlgo = anAvailableAlgsData.at( j ); - if ( aCurAlgo->Label == algoDataIn->Label ){ - isAvailable = true; - break; - } - } - } - else { - for (int j = 0; j < myAvailableHypData[i][Algo].count(); ++j) { - HypothesisData* aCurAlgo = hypData( i, Algo, j ); - if ( aCurAlgo->Label == algoDataIn->Label ){ - isAvailable = true; - break; - } - } + if ( HypothesisData* algoDataIn = SMESH::GetHypothesisData( currentHypoSet->current() )) { + for (int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++) { + int anCurrentAvailableAlgo = myAvailableHypData[i][Algo].indexOf( algoDataIn ); + if ( anCurrentAvailableAlgo > -1 ) { + isAvailable = true; + break; } - if ( isAvailable ) break; } - if ( !isAvailable ) break; + if ( !isAvailable ) + break; } } if ( isAvailable ) @@ -2843,3 +2797,35 @@ void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theI } myDlg->setHypoSets( aFilteredHypothesesSetsList ); } + +//================================================================================ +/*! + * \brief Get current name types of mesh + * \param theIndex - current index types of mesh + * \retval QString - result + */ +//================================================================================ +QString SMESHGUI_MeshOp::currentMeshTypeName( const int theIndex ) const +{ + QString aMeshType = ""; + switch ( theIndex ) { + case MT_ANY: + aMeshType = "ANY"; + break; + case MT_TRIANGULAR: + aMeshType = "TRIA"; + break; + case MT_QUADRILATERAL: + aMeshType = "QUAD"; + break; + case MT_TETRAHEDRAL: + aMeshType = "TETRA"; + break; + case MT_HEXAHEDRAL: + aMeshType = "HEXA"; + break; + default:; + } + return aMeshType; +} +