X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI_MeshOp.cxx;h=89a7a0b6a77702d0faac5d9ff04174a5ce4ad944;hp=c40e098aafafa2adc10a1bcc5c5e8a1395cf526f;hb=1774f774430c19dac97550df32f8c64d53d18e30;hpb=0fdf27b77bce6d48fa08a35ded5a5af3d13834e8

diff --git a/src/SMESHGUI/SMESHGUI_MeshOp.cxx b/src/SMESHGUI/SMESHGUI_MeshOp.cxx
index c40e098aa..89a7a0b6a 100644
--- a/src/SMESHGUI/SMESHGUI_MeshOp.cxx
+++ b/src/SMESHGUI/SMESHGUI_MeshOp.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015  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
@@ -26,15 +26,15 @@
 #include "SMESHGUI_MeshOp.h"
 
 #include "SMESHGUI.h"
+#include "SMESHGUI_GEOMGenUtils.h"
+#include "SMESHGUI_Hypotheses.h"
+#include "SMESHGUI_HypothesesUtils.h"
 #include "SMESHGUI_MeshDlg.h"
+#include "SMESHGUI_Operations.h"
 #include "SMESHGUI_ShapeByMeshDlg.h"
-#include "SMESHGUI_HypothesesUtils.h"
-#include "SMESHGUI_Hypotheses.h"
 #include "SMESHGUI_Utils.h"
-#include "SMESHGUI_GEOMGenUtils.h"
-
-#include <SMESH_TypeFilter.hxx>
-#include <SMESH_NumberFilter.hxx>
+#include "SMESH_NumberFilter.hxx"
+#include "SMESH_TypeFilter.hxx"
 
 // SALOME GEOM includes
 #include <GEOM_SelectionFilter.h>
@@ -247,8 +247,9 @@ void SMESHGUI_MeshOp::startOperation()
     myDlg->activateObject( myIsMesh ? SMESHGUI_MeshDlg::Geom : SMESHGUI_MeshDlg::Mesh );
   }
   else
+  {
     myDlg->activateObject( SMESHGUI_MeshDlg::Obj );
-
+  }
   myDlg->setCurrentTab( SMESH::DIM_3D );
 
   QStringList TypeMeshList;
@@ -363,15 +364,39 @@ bool SMESHGUI_MeshOp::isSubshapeOk() const
       // skl for NPAL14695 - implementation of searching of mainObj
       GEOM::GEOM_Object_var mainObj = op->GetMainShape(aSubGeomVar); /* _var not _wrap as
                                                                         mainObj already exists! */
-      while(1) {
-        if (mainObj->_is_nil())
-          return false;
+      while( !mainObj->_is_nil()) {
         CORBA::String_var entry1 = mainObj->GetEntry();
         CORBA::String_var entry2 = mainGeom->GetEntry();
         if (std::string( entry1.in() ) == entry2.in() )
           return true;
         mainObj = op->GetMainShape(mainObj);
       }
+      if ( aSubGeomVar->GetShapeType() == GEOM::COMPOUND )
+      {
+        // is aSubGeomVar a compound of sub-shapes?
+        GEOM::GEOM_IShapesOperations_wrap sop = geomGen->GetIShapesOperations(aStudy->StudyId());
+        if (sop->_is_nil()) return false;
+        GEOM::ListOfLong_var ids = sop->GetAllSubShapesIDs( aSubGeomVar,
+                                                            GEOM::SHAPE,/*sorted=*/false);
+        if ( ids->length() > 0 )
+        {
+          ids->length( 1 );
+          GEOM::GEOM_Object_var compSub = geomGen->AddSubShape( aSubGeomVar, ids );
+          if ( !compSub->_is_nil() )
+          {
+            GEOM::ListOfGO_var shared = sop->GetSharedShapes( mainGeom,
+                                                              compSub,
+                                                              compSub->GetShapeType() );
+            geomGen->RemoveObject( compSub );
+            compSub->UnRegister();
+            if ( shared->length() > 0 ) {
+              geomGen->RemoveObject( shared[0] );
+              shared[0]->UnRegister();
+            }
+            return ( shared->length() > 0 );
+          }
+        }
+      }
     }
   }
 
@@ -380,8 +405,8 @@ bool SMESHGUI_MeshOp::isSubshapeOk() const
 
 //================================================================================
 /*!
- * \brief Return name of the algorithm that does not support submeshes and makes
- * submesh creation useless
+ * \brief Return name of the algorithm that does not support sub-meshes and makes
+ * sub-mesh creation useless
  *  \retval char* - string is to be deleted!!!
  */
 //================================================================================
@@ -398,7 +423,8 @@ char* SMESHGUI_MeshOp::isSubmeshIgnored() const
       THypList    algoList;
       existingHyps(3, Algo, pMesh, algoNames, algoList);
       if (!algoList.empty()) {
-        HypothesisData* algo = SMESH::GetHypothesisData( algoList[0].first->GetName() );
+        HypothesisData* algo =
+          SMESH::GetHypothesisData( SMESH::toQStr( algoList[0].first->GetName() ));
         if ( algo &&
              algo->InputTypes.empty() && // builds all dimensions it-self
              !algo->IsSupportSubmeshes )
@@ -412,7 +438,8 @@ char* SMESHGUI_MeshOp::isSubmeshIgnored() const
 //       if ( !geom->_is_nil() && geom->GetShapeType() >= GEOM::FACE ) { // WIRE, EDGE as well
         existingHyps(2, Algo, pMesh, algoNames, algoList);
         if (!algoList.empty()) {
-          HypothesisData* algo = SMESH::GetHypothesisData( algoList[0].first->GetName() );
+          HypothesisData* algo =
+            SMESH::GetHypothesisData( SMESH::toQStr( algoList[0].first->GetName() ));
           if ( algo &&
                algo->InputTypes.empty() && // builds all dimensions it-self
                !algo->IsSupportSubmeshes )
@@ -524,9 +551,17 @@ void SMESHGUI_MeshOp::selectionDone()
         for ( ; aSubShapesIter != aGEOMs.end(); aSubShapesIter++, iSubSh++) {
           QString aSubGeomEntry = (*aSubShapesIter);
           _PTR(SObject) pSubGeom = studyDS()->FindObjectID(aSubGeomEntry.toLatin1().data());
-          GEOM::GEOM_Object_var aSubGeomVar =
-            GEOM::GEOM_Object::_narrow(_CAST(SObject,pSubGeom)->GetObject());
-          aSeq[iSubSh] = aSubGeomVar;
+         
+          if( pSubGeom ) { 
+            SALOMEDS_SObject* sobj = _CAST(SObject,pSubGeom);
+            if( sobj ) {
+              GEOM::GEOM_Object_var aSubGeomVar =
+                GEOM::GEOM_Object::_narrow(sobj->GetObject());
+              if( !aSubGeomVar->_is_nil() ){
+                aSeq[iSubSh] = aSubGeomVar;
+              }
+            }
+          }
         }
       } else {
         // get geometry by selected sub-mesh
@@ -608,8 +643,8 @@ void SMESHGUI_MeshOp::selectionDone()
           myDlg->objectWg( SMESHGUI_MeshDlg::Geom, SMESHGUI_MeshDlg::Btn )->hide();
           myDlg->updateGeometry();
           myDlg->adjustSize();
-          readMesh();
           myIsMesh = submeshVar->_is_nil();
+          readMesh();
         }
         else
           myDlg->reset();
@@ -631,7 +666,7 @@ void SMESHGUI_MeshOp::selectionDone()
           {
             selectionMgr()->clearFilters();
             selectObject( pSubmesh );
-            SMESHGUI::GetSMESHGUI()->switchToOperation(704);
+            SMESHGUI::GetSMESHGUI()->switchToOperation( SMESHOp::OpEditMeshOrSubMesh );
             return;
           }
           else
@@ -824,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
@@ -831,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
  */
@@ -840,23 +931,46 @@ 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();
   bool isAlgo = ( theHypType == Algo );
-  bool isAux  = ( theHypType == AddHyp );
+  bool isAux  = ( theHypType >= AddHyp );
   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;
 }
 
 //================================================================================
@@ -871,7 +985,11 @@ void SMESHGUI_MeshOp::availableHyps( const int       theDim,
  *  \param theAlgoData - to select hypos able to be used by this algo (optional)
  *
  * Gets existing (i.e. already created) hypotheses or algorithm in accordance with
- * input parameters
+ * input parameters.
+ *
+ * WARNING: when using this method to get hyps existing in Mesh component,
+ *          call availableHyps() before in order to get only hyps of available types
+ *          that was filtered by availableHyps()
  */
 //================================================================================
 void SMESHGUI_MeshOp::existingHyps( const int       theDim,
@@ -879,7 +997,7 @@ void SMESHGUI_MeshOp::existingHyps( const int       theDim,
                                     _PTR(SObject)   theFather,
                                     QStringList&    theHyps,
                                     THypList&       theHypList,
-                                    HypothesisData* theAlgoData)
+                                    HypothesisData* theAlgoData) const
 {
   // Clear hypoheses list
   theHyps.clear();
@@ -888,20 +1006,21 @@ void SMESHGUI_MeshOp::existingHyps( const int       theDim,
   if ( !theFather )
     return;
 
-  const bool isAux  = ( theHypType == AddHyp );
-
   _PTR(SObject)          aHypRoot;
   _PTR(GenericAttribute) anAttr;
   _PTR(AttributeName)    aName;
   _PTR(AttributeIOR)     anIOR;
 
-  bool isMesh = !_CAST( SComponent, theFather );
+  const bool isMesh = !_CAST( SComponent, theFather );
   int aPart = -1;
   if ( isMesh )
     aPart = theHypType == Algo ? SMESH::Tag_RefOnAppliedAlgorithms : SMESH::Tag_RefOnAppliedHypothesis;
   else
     aPart = theHypType == Algo ? SMESH::Tag_AlgorithmsRoot : SMESH::Tag_HypothesisRoot;
 
+  const bool isAux   = ( theHypType >= AddHyp );
+  const bool allHyps = ( !isMesh && theHypType != Algo && theDim > -1);
+
   if ( theFather->FindSubObject( aPart, aHypRoot ) )
   {
     _PTR(ChildIterator) anIter =
@@ -929,9 +1048,10 @@ void SMESHGUI_MeshOp::existingHyps( const int       theDim,
             CORBA::String_var hypType = aHypVar->GetName();
             HypothesisData* aData = SMESH::GetHypothesisData( hypType.in() );
             if ( !aData) continue;
-            if ( ( theDim == -1 || aData->Dim.contains( theDim ) ) &&
-                 ( isCompatible ( theAlgoData, aData, theHypType )) &&
-                 ( theHypType == Algo || isAux == aData->IsAuxOrNeedHyp ))
+            if (( theDim == -1 || aData->Dim.contains( theDim ) ) &&
+                ( isCompatible ( theAlgoData, aData, theHypType )) &&
+                ( theHypType == Algo || isAux == aData->IsAuxOrNeedHyp ) &&
+                ( !allHyps || myAvailableHypData[theDim][theHypType].count(aData) ))
             {
               std::string aHypName = aName->Value();
               theHyps.append( aHypName.c_str() );
@@ -1031,6 +1151,71 @@ SMESHGUI_MeshOp::getInitParamsHypothesis( const QString& aHypType,
   return hyp;
 }
 
+//================================================================================
+/*!
+ * \brief initialize a hypothesis creator
+ */
+//================================================================================
+
+void SMESHGUI_MeshOp::initHypCreator( SMESHGUI_GenericHypothesisCreator* theCreator )
+{
+  if ( !theCreator ) return;
+
+  // Set shapes, of mesh and sub-mesh if any
+
+  // get Entry of the Geom object
+  QString aGeomEntry = "";
+  QString aMeshEntry = "";
+  QString anObjEntry = "";
+  aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
+  aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
+  anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
+
+  if ( myToCreate && myIsMesh )
+    aMeshEntry = aGeomEntry;
+
+  if ( aMeshEntry != aGeomEntry ) { // Get Geom object from Mesh of a sub-mesh being edited
+    _PTR(SObject) pObj = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
+    GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
+    aMeshEntry = ( aGeomVar->_is_nil() ) ? QString() : SMESH::toQStr( aGeomVar->GetStudyEntry() );
+  }
+
+  if ( aMeshEntry == "" && aGeomEntry == "" ) { // get geom of an object being edited
+    _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
+    bool isMesh;
+    GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj, &isMesh );
+    if ( !aGeomVar->_is_nil() )
+    {
+      aGeomEntry = SMESH::toQStr( aGeomVar->GetStudyEntry() );
+      if ( isMesh )
+        aMeshEntry = aGeomEntry;
+    }
+  }
+
+  if ( anObjEntry != "" && aGeomEntry != "" && aMeshEntry == "" ) {
+    // take geometry from submesh being created
+    _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
+    if ( pObj ) {
+      // if current object is sub-mesh
+      SMESH::SMESH_subMesh_var aSubMeshVar =
+        SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
+      if ( !aSubMeshVar->_is_nil() ) {
+        SMESH::SMESH_Mesh_var aMeshVar =  aSubMeshVar->GetFather();
+        if ( !aMeshVar->_is_nil() ) {
+          _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar );
+          GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( aMeshSO );
+          if ( !aGeomVar->_is_nil() )
+            aMeshEntry = SMESH::toQStr( aGeomVar->GetStudyEntry() );
+        }
+      }
+    }
+  }
+
+  theCreator->setShapeEntry( aGeomEntry );
+  if ( aMeshEntry != "" )
+    theCreator->setMainShapeEntry( aMeshEntry );
+}
+
 //================================================================================
 /*!
  * \Brief Returns tab dimention
@@ -1106,6 +1291,8 @@ void SMESHGUI_MeshOp::createHypothesis(const int theDim,
 
   myDim = theDim;
   myType = theType;
+
+  // get a unique hyp name
   QStringList aHypNames;
   TDim2Type2HypList::const_iterator aDimIter = myExistingHyps.begin();
   for ( ; aDimIter != myExistingHyps.end(); aDimIter++) {
@@ -1138,64 +1325,17 @@ void SMESHGUI_MeshOp::createHypothesis(const int theDim,
     SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(theTypeName);
 
     // Create hypothesis
-    if (aCreator) {
+    if (aCreator)
+    {
       // Get parameters appropriate to initialize a new hypothesis
       SMESH::SMESH_Hypothesis_var initParamHyp =
         getInitParamsHypothesis(theTypeName, aData->ServerLibName);
 
       removeCustomFilters(); // Issue 0020170
 
-      // Get Entry of the Geom object
-      QString aGeomEntry = "";
-      QString aMeshEntry = "";
-      QString anObjEntry = "";
-      aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
-      aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
-      anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
-
-      if ( myToCreate && myIsMesh )
-        aMeshEntry = aGeomEntry;
+      // set shapes, of mesh and sub-mesh if any
+      initHypCreator( aCreator );
 
-      if ( aMeshEntry != aGeomEntry ) { // Get Geom object from Mesh of a sub-mesh being edited
-        _PTR(SObject) pObj = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
-        GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
-        aMeshEntry = ( aGeomVar->_is_nil() ) ? "" : aMeshEntry = aGeomVar->GetStudyEntry();
-      }
-
-      if ( aMeshEntry == "" && aGeomEntry == "" ) { // get geom of an object being edited
-        _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
-        bool isMesh;
-        GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj, &isMesh );
-        if ( !aGeomVar->_is_nil() )
-        {
-          aGeomEntry = aGeomVar->GetStudyEntry();
-          if ( isMesh )
-            aMeshEntry = aGeomEntry;
-        }
-      }
-
-      if ( anObjEntry != "" && aGeomEntry != "" && aMeshEntry == "" ) {
-        // take geometry from submesh being created
-        _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
-        if ( pObj ) {
-          // if current object is sub-mesh
-          SMESH::SMESH_subMesh_var aSubMeshVar =
-            SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
-          if ( !aSubMeshVar->_is_nil() ) {
-            SMESH::SMESH_Mesh_var aMeshVar =  aSubMeshVar->GetFather();
-            if ( !aMeshVar->_is_nil() ) {
-              _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar );
-              GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( aMeshSO );
-              if ( !aGeomVar->_is_nil() )
-                aMeshEntry = aGeomVar->GetStudyEntry();
-            }
-          }
-        }
-      }
-
-      aCreator->setShapeEntry( aGeomEntry );
-      if ( aMeshEntry != "" )
-        aCreator->setMainShapeEntry( aMeshEntry );
       myDlg->setEnabled( false );
       aCreator->create(initParamHyp, aHypName, myDlg, this, SLOT( onHypoCreated( int ) ) );
       dialog = true;
@@ -1270,67 +1410,22 @@ void SMESHGUI_MeshOp::onEditHyp( const int theHypType, const int theIndex )
   if ( aHyp->_is_nil() )
     return;
 
-  SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHyp->GetName());
+  SMESHGUI_GenericHypothesisCreator* aCreator =
+    SMESH::GetHypothesisCreator( SMESH::toQStr( aHyp->GetName() ));
   if ( aCreator )
   {
-    // Get initial parameters
+    // set initial parameters
     SMESH::SMESH_Hypothesis_var initParamHyp =
-      getInitParamsHypothesis( aHyp->GetName(), aHyp->GetLibName());
+      getInitParamsHypothesis( SMESH::toQStr( aHyp->GetName() ),
+                               SMESH::toQStr( aHyp->GetLibName() ));
     aCreator->setInitParamsHypothesis( initParamHyp );
 
-    // Get Entry of the Geom object
-    QString aGeomEntry = "";
-    QString aMeshEntry = "";
-    QString anObjEntry = "";
-    aGeomEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Geom );
-    aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
-    anObjEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Obj );
+    // set shapes, of mesh and sub-mesh if any
+    initHypCreator( aCreator );
 
-    if ( myToCreate && myIsMesh )
-      aMeshEntry = aGeomEntry;
-
-    if ( aMeshEntry != aGeomEntry ) { // Get Geom object from Mesh of a sub-mesh being edited
-      _PTR(SObject) pObj = studyDS()->FindObjectID( aMeshEntry.toLatin1().data() );
-      GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj );
-      aMeshEntry = ( aGeomVar->_is_nil() ) ? "" : aMeshEntry = aGeomVar->GetStudyEntry();
-    }
-
-    if ( aMeshEntry == "" && aGeomEntry == "" ) { // get geom of an object being edited
-      _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
-      bool isMesh;
-      GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( pObj, &isMesh );
-      if ( !aGeomVar->_is_nil() )
-      {
-        aGeomEntry = aGeomVar->GetStudyEntry();
-        if ( isMesh )
-          aMeshEntry = aGeomEntry;
-      }
-    }
-
-    if ( anObjEntry != "" && aGeomEntry != "" && aMeshEntry == "" ) {
-      // take geometry from submesh being created
-      _PTR(SObject) pObj = studyDS()->FindObjectID( anObjEntry.toLatin1().data() );
-      if ( pObj ) {
-        // if current object is sub-mesh
-        SMESH::SMESH_subMesh_var aSubMeshVar =
-          SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
-        if ( !aSubMeshVar->_is_nil() ) {
-          SMESH::SMESH_Mesh_var aMeshVar =  aSubMeshVar->GetFather();
-          if ( !aMeshVar->_is_nil() ) {
-            _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshVar );
-            GEOM::GEOM_Object_var aGeomVar = SMESH::GetShapeOnMeshOrSubMesh( aMeshSO );
-            if ( !aGeomVar->_is_nil() )
-              aMeshEntry = aGeomVar->GetStudyEntry();
-          }
-        }
-      }
-    }
-
-    aCreator->setShapeEntry( aGeomEntry );
-    if ( aMeshEntry != "" )
-      aCreator->setMainShapeEntry( aMeshEntry );
     removeCustomFilters(); // Issue 0020170
     myDlg->setEnabled( false );
+
     aCreator->edit( aHyp.in(), aHypItem.second, dlg(), this, SLOT( onHypoEdited( int ) ) );
   }
 }
@@ -1405,47 +1500,49 @@ 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 ( isAccessibleDim( aDim - 1 ) ) {
+      if ( algoData && myIsOnGeometry ) {
+        for (int i = aDim - 1; i >= SMESH::DIM_0D; i--) {
+          if ( isAccessibleDim( i ) && currentHyp( i, Algo ) < 0 ) {
             myDlg->disableTab( i );
             setCurrentHyp(i, Algo, -1);
           }
+        }
+      }
     }
-    else if ( algoData && myIsOnGeometry && !algoData->InputTypes.isEmpty() )
-    {
+    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 );
+    if ( !algoData ) {
+      if ( aDim != SMESH::DIM_2D || ( aDim == SMESH::DIM_2D &&
+         currentHyp( SMESH::DIM_2D, Algo ) < 0) ) {
+        for (int i = aDim - 1; i >= SMESH::DIM_0D; i--)
+          myDlg->enableTab( i );
+      }
+      else {
+        for (int i = aDim - 1; i >= SMESH::DIM_0D; i--)
+          myDlg->disableTab( 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;
     for ( ; dim * dir <= lastDim * dir; dim += dir)
     {
+      HypothesisData* nextAlgo = 0;
+      if ( myMaxShapeDim == SMESH::DIM_3D && a3DAlgo && dim == SMESH::DIM_2D ) {
+        nextAlgo = a3DAlgo;
+      }
       if ( !isAccessibleDim( dim ))
         continue;
       if ( noCompatible ) { // the selected algo has no compatible ones
@@ -1463,39 +1560,37 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
           curAlgo = 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 );
-          }
-        }
+
+      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;
       }
+      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 (myDlg->currentMeshType() == MT_ANY)
-          availableHyps( dim, Algo, anAvailable, myAvailableHypData[dim][Algo], 0 );
-      }
       myDlg->tab( dim )->setAvailableHyps( Algo, anAvailable );
       noCompatible = anAvailable.isEmpty();
-
-      // restore previously selected algo
-      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
@@ -1506,13 +1601,24 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
   {
     if ( !isAccessibleDim( dim ))
       continue;
-    for ( int type = MainHyp; type < NbHypTypes; type++ )
+
+    // get indices of selected hyps
+    const int nbTypes = nbDlgHypTypes(dim);
+    std::vector<int> hypIndexByType( nbTypes, -1 );
+    for ( int dlgType = MainHyp; dlgType < nbTypes; dlgType++ )
+    {
+      hypIndexByType[ dlgType ] = currentHyp( dim, dlgType );
+    }
+
+    // update hyps
+    for ( int dlgType = MainHyp; dlgType < nbTypes; dlgType++ )
     {
+      const int type = Min( dlgType, AddHyp );
       myAvailableHypData[ dim ][ type ].clear();
       QStringList anAvailable, anExisting;
 
       HypothesisData* curAlgo = algoByDim[ dim ];
-      int hypIndex = currentHyp( dim, type );
+      int hypIndex = hypIndexByType[ dlgType ];
 
       SMESH::SMESH_Hypothesis_var curHyp;
       if ( hypIndex >= 0 && hypIndex < myExistingHyps[ dim ][ type ].count() )
@@ -1521,12 +1627,12 @@ void SMESHGUI_MeshOp::onAlgoSelected( const int theIndex,
       if ( !myToCreate && !curAlgo && !curHyp->_is_nil() ) { // edition, algo not selected
         // try to find algo by selected hypothesis in order to keep it selected
         bool algoDeselectedByUser = ( theDim < 0 && aDim == dim );
-        CORBA::String_var curHypType = curHyp->GetName();
+        QString curHypType = SMESH::toQStr( curHyp->GetName() );
         if ( !algoDeselectedByUser &&
-            myObjHyps[ dim ][ type ].count() > 0 &&
-            !strcmp( curHypType, myObjHyps[ dim ][ type ].first().first->GetName()) )
+             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))
@@ -1542,33 +1648,35 @@ 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();
         }
-        existingHyps( dim, type, pObj, anExisting, myExistingHyps[ dim ][ type ], curAlgo);
         availableHyps( dim, type, anAvailable, myAvailableHypData[ dim ][ type ], curAlgo);
+        existingHyps( dim, type, pObj, anExisting, myExistingHyps[ dim ][ type ], curAlgo);
         defaulHypAvlbl = (type == MainHyp && !curAlgo->IsAuxOrNeedHyp );
       }
       // set list of hypotheses
-      myDlg->tab( dim )->setAvailableHyps( type, anAvailable );
-      myDlg->tab( dim )->setExistingHyps( type, anExisting, defaulHypAvlbl );
-
+      if ( dlgType <= AddHyp )
+      {
+        myDlg->tab( dim )->setAvailableHyps( type, anAvailable );
+        myDlg->tab( dim )->setExistingHyps( type, anExisting, defaulHypAvlbl );
+      }
       // set current existing hypothesis
       if ( !curHyp->_is_nil() && !anExisting.isEmpty() )
         hypIndex = this->find( curHyp, myExistingHyps[ dim ][ type ]);
       else
         hypIndex = -1;
-      if ( !isSubmesh && hypIndex < 0 && anExisting.count() == 1 ) {
+      if ( !isSubmesh && myToCreate && hypIndex < 0 && anExisting.count() == 1 ) {
         // none is yet selected => select the sole existing if it is not optional
         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 );
+      setCurrentHyp( dim, dlgType, hypIndex );
     }
   }
 }
@@ -1726,14 +1834,19 @@ bool SMESHGUI_MeshOp::createMesh( QString& theMess, QStringList& theEntryList )
       SMESH::SetName( aMeshSO, myDlg->objectText( SMESHGUI_MeshDlg::Obj ) );
     }
 
-    for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ ) {
+    for ( int aDim = SMESH::DIM_0D; aDim <= SMESH::DIM_3D; aDim++ )
+    {
       if ( !isAccessibleDim( aDim )) continue;
 
       // assign hypotheses
-      for ( int aHypType = MainHyp; aHypType <= AddHyp; aHypType++ ) {
-        int aHypIndex = currentHyp( aDim, aHypType );
-        if ( aHypIndex >= 0 && aHypIndex < myExistingHyps[ aDim ][ aHypType ].count() ) {
-          SMESH::SMESH_Hypothesis_var aHypVar = myExistingHyps[ aDim ][ aHypType ][ aHypIndex ].first;
+      for ( int dlgType = MainHyp; dlgType < nbDlgHypTypes(aDim); dlgType++ )
+      {
+        const int aHypIndex = currentHyp( aDim, dlgType );
+        const int  aHypType = Min( dlgType, AddHyp );
+        if ( aHypIndex >= 0 && aHypIndex < myExistingHyps[ aDim ][ aHypType ].count() )
+        {
+          SMESH::SMESH_Hypothesis_var aHypVar =
+            myExistingHyps[ aDim ][ aHypType ][ aHypIndex ].first;
           if ( !aHypVar->_is_nil() )
             SMESH::AddHypothesisOnMesh( aMeshVar, aHypVar );
         }
@@ -1863,9 +1976,10 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList
     if ( !anAlgoVar->_is_nil() )
       SMESH::AddHypothesisOnSubMesh( aSubMeshVar, anAlgoVar );
     // assign hypotheses
-    for ( int aHypType = MainHyp; aHypType <= AddHyp; aHypType++ )
+    for ( int dlgType = MainHyp; dlgType < nbDlgHypTypes(aDim); dlgType++ )
     {
-      int aHypIndex = currentHyp( aDim, aHypType );
+      const int aHypIndex = currentHyp( aDim, dlgType );
+      const int  aHypType = Min( dlgType, AddHyp );
       if ( aHypIndex >= 0 && aHypIndex < myExistingHyps[ aDim ][ aHypType ].count() )
       {
         SMESH::SMESH_Hypothesis_var aHypVar =
@@ -1901,6 +2015,36 @@ int SMESHGUI_MeshOp::currentHyp( const int theDim, const int theHypType ) const
   return myDlg->tab( theDim )->currentHyp( theHypType ) - 1;
 }
 
+//================================================================================
+/*!
+ * \brief Checks if a hypothesis is selected
+ */
+//================================================================================
+
+bool SMESHGUI_MeshOp::isSelectedHyp( int theDim, int theHypType, int theIndex) const
+{
+  if ( theHypType < AddHyp ) // only one hyp can be selected
+    return currentHyp( theDim, theHypType ) == theIndex;
+
+  for ( int dlgHypType = AddHyp; dlgHypType < nbDlgHypTypes( theDim ); ++dlgHypType )
+    if ( currentHyp( theDim, dlgHypType ) == theIndex )
+      return true;
+
+  return false;
+}
+
+//================================================================================
+/*!
+ * \brief Returns nb of HypType's taking into account possible several
+ *        selected additional hypotheses which are coded as additional HypType's.
+ */
+//================================================================================
+
+int SMESHGUI_MeshOp::nbDlgHypTypes( const int dim ) const
+{
+  return NbHypTypes + myDlg->tab( dim )->nbAddHypTypes();
+}
+
 //================================================================================
 /*!
  * \brief Returns true if hypotheses of given dim can be assigned
@@ -1994,8 +2138,7 @@ SMESH::SMESH_Hypothesis_var SMESHGUI_MeshOp::getAlgo( const int theDim )
   for ( ; anIter != aHypVarList.end(); anIter++)
   {
     SMESH::SMESH_Hypothesis_var aHypVar = (*anIter).first;
-    CORBA::String_var aName = aHypVar->GetName();
-    if ( !aHypVar->_is_nil() && !strcmp(aHypName.toLatin1().data(), aName) )
+    if ( !aHypVar->_is_nil() && aHypName == SMESH::toQStr( aHypVar->GetName() ))
     {
       anAlgoVar = aHypVar;
       break;
@@ -2038,8 +2181,7 @@ SMESH::SMESH_Hypothesis_var SMESHGUI_MeshOp::getAlgo( const int theDim )
     for ( anIter = aNewHypVarList.begin(); anIter != aNewHypVarList.end(); ++anIter )
     {
       SMESH::SMESH_Hypothesis_var aHypVar = (*anIter).first;
-      CORBA::String_var aName = aHypVar->GetName();
-      if ( !aHypVar->_is_nil() && !strcmp(aHypName.toLatin1().data(), aName) )
+      if ( !aHypVar->_is_nil() && aHypName == SMESH::toQStr( aHypVar->GetName() ))
       {
         anAlgoVar = aHypVar;
         break;
@@ -2099,13 +2241,13 @@ 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
-//         myAvailableHypData[ dim ][ Algo ].push_back( algoData );
-//         aHypIndex = myAvailableHypData[ dim ][ hypType ].count() - 1;
-//       }
+      //       if ( aHypIndex < 0 && algoData ) {
+      //         // assigned algo is incompatible with other algorithms
+      //         myAvailableHypData[ dim ][ Algo ].push_back( algoData );
+      //         aHypIndex = myAvailableHypData[ dim ][ hypType ].count() - 1;
+      //       }
       algoFound = ( aHypIndex > -1 );
     }
     setCurrentHyp( dim, Algo, aHypIndex );
@@ -2122,23 +2264,26 @@ void SMESHGUI_MeshOp::readMesh()
     {
       // get hypotheses
       existingHyps( dim, hypType, pObj, anExisting, myObjHyps[ dim ][ hypType ] );
-      // find index of requered hypothesis among existing ones for this dimension and type
-      int aHypIndex = -1;
-      if ( myObjHyps[ dim ][ hypType ].count() > 0 ) {
-        aHypIndex = find( myObjHyps[ dim ][ hypType ].first().first,
-                          myExistingHyps[ dim ][ hypType ] );
+      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
+        int aHypIndex = find( myObjHyps[ dim ][ hypType ][ i ].first,
+                              myExistingHyps[ dim ][ hypType ] );
         if ( aHypIndex < 0 ) {
           // assigned hypothesis is incompatible with the algorithm
           if ( currentHyp( dim, Algo ) < 0 )
           { // none algo selected; it is edition for sure, of submesh maybe
             hypWithoutAlgo = true;
-            myExistingHyps[ dim ][ hypType ].push_back( myObjHyps[ dim ][ hypType ].first() );
+            myExistingHyps[ dim ][ hypType ].push_back( myObjHyps[ dim ][ hypType ][ i ] );
+            anExisting.push_back( myObjHyps[ dim ][ hypType ][ i ].second );
             aHypIndex = myExistingHyps[ dim ][ hypType ].count() - 1;
             myDlg->tab( dim )->setExistingHyps( hypType, anExisting );
           }
         }
+        setCurrentHyp( dim, hypType + i, aHypIndex );
+
+        if ( hypType == MainHyp ) break; // only one main hyp allowed
       }
-      setCurrentHyp( dim, hypType, aHypIndex );
     }
   }
   // make available other hyps of same type as one without algo
@@ -2149,8 +2294,8 @@ void SMESHGUI_MeshOp::readMesh()
 //================================================================================
 /*!
  * \brief Gets name of object
-  * \param theSO - SObject
-  * \retval QString - name of object
+ * \param theSO - SObject
+ * \retval QString - name of object
  *
  * Gets name of object
  */
@@ -2239,7 +2384,7 @@ bool SMESHGUI_MeshOp::editMeshOrSubMesh( QString& theMess )
       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 );
@@ -2276,37 +2421,38 @@ bool SMESHGUI_MeshOp::editMeshOrSubMesh( QString& theMess )
       myObjHyps[ dim ][ Algo ].append( THypItem( anAlgoVar, aName) );
     }
 
-    // assign hypotheses
+    // remove deselected hypotheses
     for ( int hypType = MainHyp; hypType <= AddHyp; hypType++ )
     {
-      int aNewHypIndex = currentHyp( dim, hypType );
-      int anOldHypIndex = -1;
-
-      // remove old hypotheses
-      if ( myObjHyps[ dim ][ hypType ].count() > 0 )
+      for ( int i = 0, nb = myObjHyps[ dim ][ hypType ].count(); i < nb; ++i )
       {
-        anOldHypIndex = find( myObjHyps[ dim ][ hypType ].first().first,
-                              myExistingHyps[ dim ][ hypType ] );
-        if ( aNewHypIndex != anOldHypIndex || // different hyps
-             anOldHypIndex == -1 )            // hyps of different algos
+        SMESH::SMESH_Hypothesis_var hyp = myObjHyps[ dim ][ hypType ][ i ].first;
+        int hypIndex = this->find( hyp, myExistingHyps[ dim ][ hypType ]);
+        if ( !isSelectedHyp( dim, hypType, hypIndex ) && !hyp->_is_nil() )
         {
-          SMESH::RemoveHypothesisOrAlgorithmOnMesh
-            ( pObj, myObjHyps[ dim ][ hypType ].first().first );
-          myObjHyps[ dim ][ hypType ].clear();
+          SMESH::RemoveHypothesisOrAlgorithmOnMesh( pObj, hyp );
         }
       }
-
-      // assign new hypotheses
-      if ( aNewHypIndex != anOldHypIndex && aNewHypIndex > -1 )
+    }
+    // assign newly selected hypotheses
+    for ( int dlgType = MainHyp; dlgType < nbDlgHypTypes(dim); dlgType++ )
+    {
+      const int curIndex = currentHyp( dim, dlgType );
+      const int  hypType = Min( dlgType, AddHyp );
+      if ( curIndex >= 0 && curIndex < myExistingHyps[ dim ][ hypType ].count() )
       {
-        if ( isMesh )
-          SMESH::AddHypothesisOnMesh
-            (aMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
-        else if ( !aSubMeshVar->_is_nil() )
-          SMESH::AddHypothesisOnSubMesh
-            ( aSubMeshVar, myExistingHyps[ dim ][ hypType ][ aNewHypIndex ].first );
+        SMESH::SMESH_Hypothesis_var hyp = myExistingHyps[ dim ][ hypType ][ curIndex ].first;
+
+        bool isAssigned = ( this->find( hyp, myObjHyps[ dim ][ hypType ]) >= 0 );
+        if ( !isAssigned )
+        {
+          if ( isMesh )
+            SMESH::AddHypothesisOnMesh (aMeshVar, hyp );
+          else if ( !aSubMeshVar->_is_nil() )
+            SMESH::AddHypothesisOnSubMesh ( aSubMeshVar, hyp );
+        }
       }
-      // reread all hypotheses of mesh if necessary
+      // reread all hypotheses of mesh
       QStringList anExisting;
       existingHyps( dim, hypType, pObj, anExisting, myObjHyps[ dim ][ hypType ] );
     }
@@ -2349,7 +2495,7 @@ bool SMESHGUI_MeshOp::checkSubMeshConcurrency(SMESH::SMESH_Mesh_ptr    mesh,
         myDlg->setEnabled( false ); // disactivate selection
         selectionMgr()->clearFilters();
         selectObject( meshSO );
-        SMESHGUI::GetSMESHGUI()->OnGUIEvent( 713 ); // MESH_ORDER
+        SMESHGUI::GetSMESHGUI()->OnGUIEvent( SMESHOp::OpMeshOrder ); // MESH_ORDER
         qApp->processEvents();
 
         myDlg->setEnabled( true );
@@ -2430,7 +2576,7 @@ void SMESHGUI_MeshOp::onPublishShapeByMeshDlg(SUIT_Operation* op)
     GEOM::GEOM_Object_var aGeomVar = myShapeByMeshOp->GetShape();
     if ( !aGeomVar->_is_nil() )
     {
-      QString ID = aGeomVar->GetStudyEntry();
+      QString ID = SMESH::toQStr( aGeomVar->GetStudyEntry() );
       if ( _PTR(SObject) aGeomSO = studyDS()->FindObjectID( ID.toLatin1().data() )) {
         selectObject( aGeomSO );
         selectionDone();
@@ -2523,96 +2669,46 @@ void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theI
 //================================================================================
 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( 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" )
   {
+    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;
       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() )
-      {
-        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 = 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();
+      else if ( dim != SMESH::DIM_3D && currentHyp( SMESH::DIM_3D, Algo ) >= 0 )
+        isReqDisBound = true;
+      if ( isReqDisBound ) {
+        aReqDim = dim;
+        break;
+      }
     }
     if ( !myIsOnGeometry )
       for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
@@ -2621,142 +2717,100 @@ 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);
         }
       }
     }
     else if ( !isNone ) {
-      if ( aDim == SMESH::DIM_2D){
+      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--){
-            myDlg->disableTab( j );
-            setCurrentHyp( j , Algo, -1 );
+      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 - 1; j >= SMESH::DIM_0D; j--) {
+            if ( j < aDim && currentHyp( j+1, Algo ) < 0 ) {
+              myDlg->disableTab( j );
+              setCurrentHyp( j , Algo, -1 );
+            }
           }
           break;
         }
+        else if ( isNoneAlg ) {
+          myDlg->disableTab( i );
+        }
       }
     }
     myDlg->enableTab( aDim );
     myDlg->setCurrentTab( aDim );
   }
+  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 i = 0 ; i < anAvailableAlgsData.count(); i++ )
-            {
-              HypothesisData* aCurAlgo = anAvailableAlgsData.at( i );
-              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 )
@@ -2764,3 +2818,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;
+}
+