X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_MeshOp.cxx;h=8a3346e8f4364dd8fca32de7f9c73ca6cf5399ca;hp=25f2caafc3729b98987abd51b2b2b9a3661268d6;hb=73c2ea57739908ece721b3c3465ae9bb8e667149;hpb=b0a908c0d20341651771d0249fb10882f54b2aad

diff --git a/src/SMESHGUI/SMESHGUI_MeshOp.cxx b/src/SMESHGUI/SMESHGUI_MeshOp.cxx
index 25f2caafc..8a3346e8f 100644
--- a/src/SMESHGUI/SMESHGUI_MeshOp.cxx
+++ b/src/SMESHGUI/SMESHGUI_MeshOp.cxx
@@ -41,6 +41,7 @@
 #include <GEOMBase.h>
 #include <GeometryGUI.h>
 #include <GEOM_wrap.hxx>
+#include <GEOMImpl_Types.hxx>
 
 // SALOME GUI includes
 #include <SalomeApp_Tools.h>
@@ -593,7 +594,7 @@ void SMESHGUI_MeshOp::selectionDone()
       }
       myDlg->setMaxHypoDim( shapeDim );
       myMaxShapeDim = shapeDim;
-      myDlg->setHypoSets( SMESH::GetHypothesesSets( shapeDim, "" ));
+      myDlg->setHypoSets( SMESH::GetHypothesesSets( shapeDim ));
 
       if (!myToCreate) // edition: read hypotheses
       {
@@ -688,9 +689,13 @@ void SMESHGUI_MeshOp::selectionDone()
       myDlg->adjustSize();
       readMesh();
     }
+    int curIndex = myDlg->currentMeshType( );
     QStringList TypeMeshList;
     createMeshTypeList( TypeMeshList );
     setAvailableMeshType( TypeMeshList );
+    curIndex =( curIndex >= TypeMeshList.count() ) ? 0 : curIndex;
+    myDlg->setCurrentMeshType( curIndex );
+    setFilteredAlgoData( myMaxShapeDim, curIndex);
   }
   catch ( const SALOME::SALOME_Exception& S_ex )
   {
@@ -1396,26 +1401,40 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
   algoByDim[ aDim ] = algoData;
 
   QStringList anAvailable;
-  if ( !algoData ) { // all algos becomes available
-    availableHyps( aDim, Algo, anAvailable, myAvailableHypData[ aDim ][ Algo ]);
-    myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
-  }
-  // check that tab enable, if algorithm building needed algo is one less than dimension
-  if ( algoData && myIsOnGeometry && !algoData->InputTypes.isEmpty() &&
-       ( aDim > SMESH::DIM_0D ) && !isAccessibleDim( aDim - 1 ) ){
-    myDlg->enableTab( aDim - 1 );
-  }
-  if ( (myDlg->currentMeshType() != MT_ANY) &&
-       (( !algoData && ( aDim > SMESH::DIM_0D ) && isAccessibleDim( aDim - 1 )) ||
-        ( algoData && myIsOnGeometry && algoData->InputTypes.isEmpty() &&
-          ( aDim > SMESH::DIM_0D ) && isAccessibleDim( aDim - 1 ) ) ) ){
-    for (int i = aDim - 1; i >= SMESH::DIM_0D; i--){
-      if ( isAccessibleDim( i ) ) myDlg->disableTab( i );
+
+  // 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 ) ) {
+            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 );
+      }
+    }
+    myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailable );
+  }
   // 2 loops: backward and forward from algo dimension
   for ( int forward = false; forward <= true; ++forward )
   {
@@ -1444,12 +1463,26 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
           curAlgo = 0;
       }
       // set new available algoritms
-      availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], prevAlgo );
+      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 );
+          }
+        }
+      }
       HypothesisData* soleCompatible = 0;
       if ( anAvailable.count() == 1 )
         soleCompatible = myAvailableHypData[dim][Algo][0];
-      if ( dim == aTopDim && prevAlgo ) // all available algoritms should be selectable any way
-        availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], 0 );
+      if ( dim == aTopDim && prevAlgo ) {// all available algoritms should be selectable any way
+        if (myDlg->currentMeshType() == MT_ANY)
+          availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], 0 );
+      }
       myDlg->tab( dim )->setAvailableHyps( Algo, anAvailable );
       noCompatible = anAvailable.isEmpty();
 
@@ -1458,7 +1491,7 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
       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 );
+      setCurrentHyp( dim, Algo, algoIndex);
 
       // remember current algo
       prevAlgo = algoByDim[ dim ] = hypData( dim, Algo, algoIndex );
@@ -1490,8 +1523,8 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
         bool algoDeselectedByUser = ( theDim < 0 && aDim == dim );
         CORBA::String_var curHypType = curHyp->GetName();
         if ( !algoDeselectedByUser &&
-             myObjHyps[ dim ][ type ].count() > 0 &&
-             !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
+            myObjHyps[ dim ][ type ].count() > 0 &&
+            !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
         {
           HypothesisData* hypData = SMESH::GetHypothesisData( curHyp->GetName() );
           for (int i = 0; i < myAvailableHypData[ dim ][ Algo ].count(); ++i) {
@@ -1531,8 +1564,8 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
         CORBA::String_var hypTypeName = myExistingHyps[ dim ][ type ].first().first->GetName();
         bool isOptional = true;
         if ( algoByDim[ dim ] &&
-             SMESH::IsAvailableHypothesis( algoByDim[ dim ], hypTypeName.in(), isOptional ) &&
-             !isOptional )
+            SMESH::IsAvailableHypothesis( algoByDim[ dim ], hypTypeName.in(), isOptional ) &&
+            !isOptional )
           hypIndex = 0;
       }
       setCurrentHyp( dim, type, hypIndex );
@@ -2048,13 +2081,9 @@ void SMESHGUI_MeshOp::readMesh()
     }
 
     // Get name of geometry object
-    GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
-    if ( !aGeomVar->_is_nil() )
-    {
-      _PTR(SObject) aGeomSO = studyDS()->FindObjectID( aGeomVar->GetStudyEntry() );
-      QString aShapeName = name( aGeomSO );
-      myDlg->setObjectText( SMESHGUI_MeshDlg::Geom, aShapeName );
-    }
+    CORBA::String_var name = SMESH::GetGeomName( pObj );
+    if ( name.in() )
+      myDlg->setObjectText( SMESHGUI_MeshDlg::Geom, name.in() );
   }
 
   // Get hypotheses and algorithms assigned to the mesh/sub-mesh
@@ -2450,12 +2479,12 @@ void SMESHGUI_MeshOp::createMeshTypeList( QStringList& theTypeMesh)
 {
   theTypeMesh.clear();
   theTypeMesh.append( tr( "MT_ANY" ) );
-  if ( myIsOnGeometry &&  ( myMaxShapeDim >= 2 || myMaxShapeDim == -1 ) )
+  if ( myMaxShapeDim >= 2 || myMaxShapeDim == -1 )
   {
     theTypeMesh.append( tr( "MT_TRIANGULAR" ) );
     theTypeMesh.append( tr( "MT_QUADRILATERAL" ) );
   }
-  if ( myIsOnGeometry && ( myMaxShapeDim == 3 || myMaxShapeDim == -1 ) )
+  if ( myMaxShapeDim == 3 || myMaxShapeDim == -1 )
   {
     theTypeMesh.append( tr( "MT_TETRAHEDRAL" ) );
     theTypeMesh.append( tr( "MT_HEXAHEDRAL" ) );
@@ -2481,31 +2510,94 @@ void SMESHGUI_MeshOp::setAvailableMeshType( const QStringList& theTypeMesh )
  */
 //================================================================================
 void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex)
+{
+  setFilteredAlgoData( theTabIndex, theIndex);
+}
+
+//================================================================================
+/*!
+ * \brief Set a filtered list of available algorithms by mesh type
+  * \param theTabIndex - Index of current active tab
+  * \param theIndex - Index of current type of mesh
+ */
+//================================================================================
+void SMESHGUI_MeshOp::setFilteredAlgoData( const int theTabIndex, const int theIndex)
 {
   int aDim;
-  if ( !myIsOnGeometry ) return;
   THypDataList anAvailableAlgsData;
   QStringList anAvailableAlgs;
-  QString anCompareType = "ANY";
+  QString anCompareType = "";
   bool isAvailableChoiceAlgo = false;
   int anCurrentAvailableAlgo = 0;
   bool isNone = true;
   switch ( theIndex ) {
-    case MT_ANY:
+  case MT_ANY:
+    anCompareType = "ANY";
+    aDim = SMESH::DIM_3D;
+    break;
+  case MT_TRIANGULAR:
+    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( SMESHGUI_MeshDlg::Geom );
+  if ( _PTR(SObject) so = studyDS()->FindObjectID( anEntry.toLatin1().data() ))
+  {
+    CORBA::Object_var obj = _CAST( SObject,so )->GetObject();
+    aGeomVar = GEOM::GEOM_Object::_narrow( obj );
+    if ( !aGeomVar->_is_nil() && toCheckIsApplicableToAll )
+      toCheckIsApplicableToAll = ( aGeomVar->GetType() == GEOM_GROUP );
+  }
+
+  if ( anCompareType == "ANY" )
+  {
+    for ( int dim = SMESH::DIM_3D; dim >= SMESH::DIM_2D; dim-- )
     {
-      for ( int dim = SMESH::DIM_2D; dim <= SMESH::DIM_3D; dim++ )
+      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;
+      if ( !isNone && !myAvailableHypData[dim][Algo].empty() ) {
+        algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
+      }
+      myAvailableHypData[dim][Algo].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() )
       {
-        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
-        if ( !isNone && !myAvailableHypData[dim][Algo].empty() ){
-          for (int i = 0 ; i < anAvailableAlgsData.count(); i++)
+        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 );
+          }
+        }
+        if ( !isNone && algoCur ) {
+          for (int i = 0 ; i < myAvailableHypData[dim][Algo].count(); i++)
           {
-            HypothesisData* algoAny = anAvailableAlgsData.at(i);
-            HypothesisData* algoCur = myAvailableHypData[dim][Algo].at( currentHyp( dim, Algo ) );
-            QString tem = algoAny->Label;
+            HypothesisData* algoAny = myAvailableHypData[dim][Algo].at(i);
             if ( algoAny->Label == algoCur->Label ){
               isAvailableChoiceAlgo = true;
               anCurrentAvailableAlgo = i;
@@ -2513,110 +2605,108 @@ void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theI
             }
           }
         }
-        else if ( !isNone ){
+        else if ( !isNone ) {
           isAvailableChoiceAlgo = true;
           anCurrentAvailableAlgo = currentHyp( dim, Algo );
         }
-        //set new algorithm list and select the current algorithm
-        myAvailableHypData[dim][Algo] = anAvailableAlgsData;
-        myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
-        if ( isAvailableChoiceAlgo )
-          setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
       }
-      int aMaxShapeDim = ( myMaxShapeDim == -1 ) ? SMESH::DIM_3D : myMaxShapeDim;
-      for ( int i = SMESH::DIM_0D; i <= aMaxShapeDim; i++ ) {
-        myDlg->enableTab( i );
+      myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
+      if ( isAvailableChoiceAlgo )
+        setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
+    }
+    if ( !myIsOnGeometry )
+      for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
+        if ( i < SMESH::DIM_3D ) myDlg->disableTab( i );
+        else                     myDlg->enableTab( i );
       }
-      myDlg->setCurrentTab( theTabIndex );
-      myDlg->setHypoSets( SMESH::GetHypothesesSets( aMaxShapeDim, "" ) );
-    }
-    break;
-    case MT_TRIANGULAR:{
-      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:;
+    else
+      for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
+        if ( i > myMaxShapeDim ) myDlg->disableTab( i );
+        else                     myDlg->enableTab( i );
+      }
+    myDlg->setCurrentTab( theTabIndex );
   }
-  if ( anCompareType != "ANY" )
+  else
   {
     QString anCurrentAlgo;
     bool isReqDisBound = true;
+    QString anCurrentCompareType = anCompareType;
     isNone = currentHyp( aDim, Algo ) < 0;
-    // retrieves a list of available algorithms from resources
-    availableHyps( aDim, Algo, anAvailableAlgs, anAvailableAlgsData );
-    // finding algorithm which is selected
     if ( !isNone && !myAvailableHypData[aDim][Algo].empty() &&
-         myAvailableHypData[aDim][Algo].count() != anAvailableAlgsData.count() ){
-      anCurrentAlgo = myAvailableHypData[aDim][Algo].at( currentHyp( aDim, Algo ) )->Label;
+        myAvailableHypData[aDim][Algo].count() != anAvailableAlgsData.count() )
       isReqDisBound = myAvailableHypData[aDim][Algo].at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty();
-    }
-    else if ( !isNone ){
-      anCurrentAlgo = anAvailableAlgsData.at( currentHyp( aDim, Algo ) )->Label;
+    else if ( !isNone )
       isReqDisBound = anAvailableAlgsData.at( currentHyp( aDim, Algo ) )->InputTypes.isEmpty();
-    }
-    anAvailableAlgs.clear();
-    myAvailableHypData[aDim][Algo].clear();
-    // finding and adding algorithm depending on the type mesh
-    for ( int i = 0 ; i < anAvailableAlgsData.count(); i++ )
+    for ( int dim = aDim; dim >= SMESH::DIM_2D; dim-- )
     {
-      HypothesisData* algoIn = anAvailableAlgsData.at( i );
-      bool isAvailableAlgo = ( algoIn->OutputTypes.count() == 0 );
-      QStringList::const_iterator inElemType = algoIn->OutputTypes.begin();
-      for ( ; inElemType != algoIn->OutputTypes.end(); inElemType++ )
+      bool isNoneAlg = currentHyp( dim, Algo ) < 0;
+      isAvailableChoiceAlgo = false;
+      // retrieves a list of available algorithms from resources
+      availableHyps( dim, Algo, anAvailableAlgs, anAvailableAlgsData );
+      // 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++ )
       {
-        if ( *inElemType == anCompareType ){
-          isAvailableAlgo = true;
-          break;
+        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 ( isAvailableAlgo || algoIn->OutputTypes.count()==0 ){
-        anAvailableAlgs.append( algoIn->Label );
-        myAvailableHypData[aDim][Algo].append( algoIn );
-      }
-      //algorithm will be active, if the chosen algorithm available in the current mesh type
-      if ( !isNone &&  isAvailableAlgo && algoIn->Label == anCurrentAlgo ){
-        isAvailableChoiceAlgo = true;
-        anCurrentAvailableAlgo = anAvailableAlgs.count() - 1 ;
-      }
+      //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 );
     }
-    //set new algorithm list and select the current algorithm
-    myDlg->tab( aDim )->setAvailableHyps( Algo, anAvailableAlgs );
-    if ( isAvailableChoiceAlgo )
-      setCurrentHyp( aDim, Algo, anCurrentAvailableAlgo );
-    int aMaxShapeDim = ( myMaxShapeDim == -1 ) ? SMESH::DIM_3D : myMaxShapeDim;
-    if ( isNone || isReqDisBound || !isAvailableChoiceAlgo ) {
-      for ( int i = SMESH::DIM_0D; i <= aMaxShapeDim; i++ ) {
+
+    if ( isNone || isReqDisBound ) {
+      for ( int i = SMESH::DIM_0D; i <= myMaxShapeDim; i++ ) {
         if ( aDim != i ) {
           myDlg->disableTab( i );
           setCurrentHyp(i, Algo, -1);
         }
       }
     }
-    else if ( !isNone ){
+    else if ( !isNone ) {
       if ( aDim == SMESH::DIM_2D){
         myDlg->disableTab( SMESH::DIM_3D );
         setCurrentHyp( SMESH::DIM_3D, Algo, -1);
       }
-      for ( int i = aMaxShapeDim; i > SMESH::DIM_0D; i-- )
+      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 ( aMaxShapeDim != i && isReqDisBound) {
+        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--){
             myDlg->disableTab( j );
             setCurrentHyp( j , Algo, -1 );
@@ -2625,8 +2715,52 @@ void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theI
         }
       }
     }
-    myDlg->setHypoSets( SMESH::GetHypothesesSets( aDim, anCompareType ) );
     myDlg->enableTab( aDim );
     myDlg->setCurrentTab( aDim );
   }
+  QStringList aHypothesesSetsList = SMESH::GetHypothesesSets( aDim );
+  QStringList aFilteredHypothesesSetsList;
+  aFilteredHypothesesSetsList.clear();
+  QStringList::const_iterator inHypoSetName = aHypothesesSetsList.begin();
+  for ( ; inHypoSetName != aHypothesesSetsList.end(); ++inHypoSetName )
+  {
+    HypothesesSet* currentHypoSet = SMESH::GetHypothesesSet( *inHypoSetName );
+    bool isAvailable = false;
+    currentHypoSet->init( true );
+    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 ( isAvailable ) break;
+        }
+        if ( !isAvailable ) break;
+      }
+    }
+    if ( isAvailable )
+      aFilteredHypothesesSetsList.append( *inHypoSetName );
+  }
+  myDlg->setHypoSets( aFilteredHypothesesSetsList );
 }