X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI.cxx;h=69cbc7390bcfaa078d777a057ee03f7710147467;hb=66c7e4a32db7714e0215a1b1edce997759e5d573;hp=5c3cfa08e7377d5f9b1cc59f54b515a5426d83b0;hpb=03d855b75b0404e50b1b4a74d52f45d9de50654a;p=modules%2Fsmesh.git

diff --git a/src/SMESHGUI/SMESHGUI.cxx b/src/SMESHGUI/SMESHGUI.cxx
index 5c3cfa08e..69cbc7390 100644
--- a/src/SMESHGUI/SMESHGUI.cxx
+++ b/src/SMESHGUI/SMESHGUI.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -32,6 +32,8 @@
 #include "SMESHGUI.h"
 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
 #include "SMESHGUI_AddMeshElementDlg.h"
+#include "SMESHGUI_AddNodeOnSegmentDlg.h"
+#include "SMESHGUI_AddNodeOnFaceDlg.h"
 #include "SMESHGUI_AddQuadraticElementDlg.h"
 #include "SMESHGUI_BuildCompoundDlg.h"
 #include "SMESHGUI_ClippingDlg.h"
@@ -61,7 +63,9 @@
 #include "SMESHGUI_Hypotheses.h"
 #include "SMESHGUI_HypothesesUtils.h"
 #include "SMESHGUI_MG_ADAPTDRIVER.h"
+#include "SMESHGUI_HomardAdaptDlg.h"
 #include "SMESHGUI_Make2DFrom3DOp.h"
+#include "SMESHGUI_MakeFull2DFrom3DOp.h"
 #include "SMESHGUI_MakeNodeAtPointDlg.h"
 #include "SMESHGUI_Measurements.h"
 #include "SMESHGUI_MergeDlg.h"
@@ -78,6 +82,7 @@
 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
 #include "SMESHGUI_PropertiesDlg.h"
 #include "SMESHGUI_RemoveElementsDlg.h"
+#include "SMESHGUI_RemoveNodeReconnectionDlg.h"
 #include "SMESHGUI_RemoveNodesDlg.h"
 #include "SMESHGUI_RenumberingDlg.h"
 #include "SMESHGUI_ReorientFacesDlg.h"
@@ -93,6 +98,8 @@
 #include "SMESHGUI_SymmetryDlg.h"
 #include "SMESHGUI_TranslationDlg.h"
 #include "SMESHGUI_TransparencyDlg.h"
+#include "SMESHGUI_CreateDualMeshDlg.h"
+#include "SMESHGUI_CreateDualMeshOp.h"
 #include "SMESHGUI_Utils.h"
 #include "SMESHGUI_VTKUtils.h"
 
@@ -105,7 +112,6 @@
 #include "SMESH_ControlsDef.hxx"
 #include "SMESH_ScalarBarActor.h"
 #include "SMESH_TypeFilter.hxx"
-#include "SMESH_Component_Generator.hxx"
 
 // SALOME GUI includes
 #include <LightApp_DataOwner.h>
@@ -145,6 +151,7 @@
 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
+#include CORBA_CLIENT_HEADER(SMESH_Homard)
 
 // Qt includes
 // #define       INCLUDE_MENUITEM_DEF // VSR commented ????????
@@ -239,11 +246,6 @@ namespace
               theCommandID == SMESHOp::OpPopupImportCGNS ) {
       filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
     }
-    else if ( theCommandID == SMESHOp::OpImportSAUV ||
-              theCommandID == SMESHOp::OpPopupImportSAUV ) {
-      filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
-      filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
-    }
     else if ( theCommandID == SMESHOp::OpImportGMF ||
               theCommandID == SMESHOp::OpPopupImportGMF ) {
       filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"  );
@@ -345,18 +347,6 @@ namespace
               }
               break;
             }
-          case SMESHOp::OpImportSAUV:
-          case SMESHOp::OpPopupImportSAUV:
-            {
-              // SAUV format
-              SMESH::DriverMED_ReadStatus res;
-              aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
-              if ( res != SMESH::DRS_OK ) {
-                errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
-                               arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
-              }
-              break;
-            }
           case SMESHOp::OpImportGMF:
           case SMESHOp::OpPopupImportGMF:
             {
@@ -448,8 +438,6 @@ namespace
                          theCommandID == SMESHOp::OpPopupExportSTL );
     const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
                          theCommandID == SMESHOp::OpPopupExportCGNS );
-    const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
-                         theCommandID == SMESHOp::OpPopupExportSAUV );
     const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
                          theCommandID == SMESHOp::OpPopupExportGMF );
 
@@ -460,6 +448,7 @@ namespace
     bool aCheckWarn = true;
     if ( resMgr )
       aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
+
     // get mesh object from selection and check duplication of their names
     bool hasDuplicatedMeshNames = false;
     QList< QPair< SMESH::SMESH_IDSource_var, QString > >           aMeshList;
@@ -528,7 +517,7 @@ namespace
     SMESH::SMESH_Mesh_var            aMesh = aMeshOrGroup->GetMesh();
     QString                      aMeshName = (*aMeshIter).second;
 
-    if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
+    if ( isMED || isCGNS ) // formats where group names must be unique
     {
       // check for equal group names within each mesh
       for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
@@ -580,18 +569,6 @@ namespace
       format = "CGNS";
       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
     }
-    else if ( isSAUV )
-    {
-      format = "SAUV";
-      notSupportedElemTypes.push_back( SMESH::Entity_Ball );
-      notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
-      notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
-      notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
-      notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
-      notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
-      notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
-      notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
-    }
     else if ( isGMF )
     {
       format = "GMF";
@@ -608,7 +585,7 @@ namespace
     }
     if ( ! notSupportedElemTypes.empty() )
     {
-      SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
+      SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
       for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
         if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
           presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
@@ -628,8 +605,8 @@ namespace
         "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
       };
       // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
-      const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
-      int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
+      static_assert( sizeof(typeMsg) / sizeof(const char*) == SMESH::Entity_Last,
+                     "Update names of EntityType's!!!" );
 
       QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
       for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
@@ -655,12 +632,12 @@ namespace
 
     // Init the parameters with the default values
     bool aIsASCII_STL   = true;
-    bool toCreateGroups = false;
-    if ( resMgr )
-      toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
-    bool toOverwrite  = true;
-    bool toFindOutDim = true;
-    double       zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
+    bool toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
+    bool   toOverwrite  = true;
+    bool   toFindOutDim = true;
+    bool    saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
+    bool     toRenumber = true;
+    double         zTol = resMgr->doubleValue( "SMESH", "med_ztolerance", 0. );
 
     QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
     QString anInitialPath = "";
@@ -670,44 +647,46 @@ namespace
     QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
 
     // Get a file name to write in and additional options
-    if ( isUNV || isDAT || isGMF ) // Export w/o options
+    if ( isGMF ) // Export w/o options
     {
-      if ( isUNV )
-        aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
-      else if ( isDAT )
-        aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
-      else if ( isGMF )
-        aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
-          ";;" +  QObject::tr( "GMF_BINARY_FILES_FILTER" )  + " (*.meshb)";
-     if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
+      aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER"  ) + " (*.mesh)" +
+        ";;" +  QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
+      if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
+
       aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
                                             anInitialPath + QString("/") + aMeshName,
                                             aFilter, aTitle, false);
     }
-    else if ( isCGNS )// Export to CGNS
+    else if ( isCGNS || isUNV || isDAT ) // Export to [ CGNS | UNV | DAT ] - one option
     {
-      const char* theByTypeResource = "cgns_group_elems_by_type";
-      toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
+      const char* theOptionResource = isCGNS ? "cgns_group_elems_by_type" : "export_renumber";
+      bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
 
       QStringList checkBoxes;
-      checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
+      checkBoxes << QObject::tr( isCGNS ? "CGNS_EXPORT_ELEMS_BY_TYPE" : "SMESH_RENUMBER" );
 
       SalomeApp_CheckFileDlg* fd =
         new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
       fd->setWindowTitle( aTitle );
-      fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
+      if ( isCGNS )
+        fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
+      else if ( isUNV )
+        fd->setNameFilter( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
+      else if ( isDAT )
+        fd->setNameFilter( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
       if ( !anInitialPath.isEmpty() )
         fd->setDirectory( anInitialPath );
-      fd->selectFile(aMeshName);
+      fd->selectFile( aMeshName );
       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
       fd->setValidator( fv );
-      fd->SetChecked( toCreateGroups, 0 );
+      fd->SetChecked( option, 0 );
 
       if ( fd->exec() )
         aFilename = fd->selectedFile();
-      toOverwrite    = fv->isOverwrite(aFilename);
-      toCreateGroups = fd->IsChecked(0);
-      SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
+      toOverwrite    = fv->isOverwrite( aFilename );
+      option = fd->IsChecked( 0 );
+      SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
+      ( isCGNS ? toCreateGroups : toRenumber ) = option;
 
       delete fd;
     }
@@ -738,27 +717,19 @@ namespace
       }
       delete fd;
     }
-    else if ( isMED || isSAUV ) // Export to MED or SAUV
+    else if ( isMED ) // Export to MED
     {
       int defaultVersion = 0;
       QMap<QString, int> aFilterMap;
-      if ( isMED ) {
-        //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
-        //QString vmed (aMesh->GetVersionString(-1, 2));
-        SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
-        if ( mvok->length() > 0)
-          defaultVersion = mvok[0]; // the current version to set the default filter on it
-        for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
-        {
-          QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
-          MESSAGE("MED version: " << vs.toStdString());
-          aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)",  mvok[i]);
-        }
-      }
-      else { // isSAUV
-        aFilterMap.insert("All files (*)", -1 );
-        aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
-        aFilterMap.insert("SAUV files (*.sauve)", -1 );
+      //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
+      //QString vmed (aMesh->GetVersionString(-1, 2));
+      SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
+      if ( mvok->length() > 0)
+        defaultVersion = mvok[0]; // the current version to set the default filter on it
+      for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
+      {
+        QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
+        aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)",  mvok[i]);
       }
       QStringList filters;
       QMap<QString, int>::const_iterator it = aFilterMap.begin();
@@ -769,7 +740,9 @@ namespace
           aDefaultFilter = it.key();
       }
       QStringList checkBoxes;
-      checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
+      checkBoxes << QObject::tr("SMESH_AUTO_GROUPS")
+                 << QObject::tr("SMESH_AUTO_DIM")
+                 << QObject::tr("SMESH_MED_SAVE_NUMS");
 
       SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
       QList< QWidget* > wdgList;
@@ -797,6 +770,7 @@ namespace
       fd->selectNameFilter( aDefaultFilter );
       fd->SetChecked( toCreateGroups, 0 );
       fd->SetChecked( toFindOutDim,   1 );
+      fd->SetChecked( saveNumbers,    2 );
       if ( !anInitialPath.isEmpty() )
         fd->setDirectory( anInitialPath );
       fd->selectFile(aMeshName);
@@ -887,6 +861,7 @@ namespace
       }
       toCreateGroups = fd->IsChecked(0);
       toFindOutDim   = fd->IsChecked(1);
+      saveNumbers    = fd->IsChecked(2);
       zTol           = zTolCheck->isChecked() ? zTolSpin->value() : -1;
       fieldSelWdg->GetSelectedFields();
       if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
@@ -924,9 +899,8 @@ namespace
 //           if ( SMESHGUI::automaticUpdate() )
 //             SMESH::UpdateView();
 //         }
-        if ( isMED && isOkToWrite)
+        if ( isMED && isOkToWrite )
         {
-          MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
           aMeshIter = aMeshList.begin();
           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
           {
@@ -934,39 +908,26 @@ namespace
             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
             const GEOM::ListOfFields&       fields = aFieldList[ aMeshIndex ].first.in();
             const QString&            geoAssFields = aFieldList[ aMeshIndex ].second;
-            const bool                   hasFields = ( fields.length() || !geoAssFields.isEmpty() );
-            if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
-              aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
-                                    toOverwrite && aMeshIndex == 0, toFindOutDim );
-            else
-              aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
-                                          toCreateGroups, aFormat,
-                                          toOverwrite && aMeshIndex == 0, toFindOutDim,
-                                          fields, geoAssFields.toLatin1().data(), zTol );
-          }
-        }
-        else if ( isSAUV )
-        {
-          for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
-          {
-            SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
-            if( !aMeshItem->_is_nil() )
-              aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
+
+            aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
+                                        toCreateGroups, aFormat,
+                                        toOverwrite && aMeshIndex == 0, toFindOutDim,
+                                        fields, geoAssFields.toLatin1().data(), zTol, saveNumbers );
           }
         }
         else if ( isDAT )
         {
           if ( aMeshOrGroup->_is_equivalent( aMesh ))
-            aMesh->ExportDAT( aFilename.toUtf8().data() );
+            aMesh->ExportDAT( aFilename.toUtf8().data(), toRenumber );
           else
-            aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
+            aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
         }
         else if ( isUNV )
         {
           if ( aMeshOrGroup->_is_equivalent( aMesh ))
-            aMesh->ExportUNV( aFilename.toUtf8().data() );
+            aMesh->ExportUNV( aFilename.toUtf8().data(), toRenumber );
           else
-            aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
+            aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
         }
         else if ( isSTL )
         {
@@ -994,11 +955,19 @@ namespace
           aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
         }
       }
-      catch (const SALOME::SALOME_Exception& S_ex){
+      catch (const SALOME::SALOME_Exception& S_ex)
+      {
         wc.suspend();
-        SUIT_MessageBox::warning(SMESHGUI::desktop(),
-                                 QObject::tr("SMESH_WRN_WARNING"),
-                                 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
+        if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
+             strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
+
+          SUIT_MessageBox::critical(SMESHGUI::desktop(),
+                                    QObject::tr("SMESH_WRN_WARNING"),
+                                    QObject::tr(S_ex.details.text.in() ));
+        else
+          SUIT_MessageBox::warning(SMESHGUI::desktop(),
+                                   QObject::tr("SMESH_WRN_WARNING"),
+                                   QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
         wc.resume();
       }
     }
@@ -1152,6 +1121,8 @@ namespace
       type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
     else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
       type = QObject::tr( "WARP_ELEMENTS" );
+    else if (dynamic_cast<SMESH::Controls::Warping3D*>(f.get()))
+      type = QObject::tr("WARP_3D_ELEMENTS");
     else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
       type = QObject::tr( "TAPER_ELEMENTS" );
     else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
@@ -1194,6 +1165,8 @@ namespace
       type = QObject::tr( "EQUAL_VOLUME" );
     else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
       type = QObject::tr( "NODE_CONNECTIVITY_NB" );
+    else if ( dynamic_cast< SMESH::Controls::ScaledJacobian* >( f.get() ) )
+      type = QObject::tr( "SCALED_JACOBIAN" );
     return type;
   }
 
@@ -1218,14 +1191,14 @@ namespace
             SMESH::Controls::NumericalFunctor* aNumFun =
               dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
             if ( aNumFun ) {
-              std::vector<int> elements;
+              std::vector<smIdType> elements;
               SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
               if ( mesh->_is_nil() ) {
                 SMESH::SMESH_IDSource_var idSource =
                   SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
                 if ( !idSource->_is_nil() )
                 {
-                  SMESH::long_array_var ids = idSource->GetIDs();
+                  SMESH::smIdType_array_var ids = idSource->GetIDs();
                   elements.resize( ids->length() );
                   for ( unsigned i = 0; i < elements.size(); ++i )
                     elements[i] = ids[i];
@@ -1809,7 +1782,9 @@ namespace
     ActionControl.Bind( SMESHOp::OpMaxElementLength2D,    SMESH_Actor::eMaxElementLength2D );
     ActionControl.Bind( SMESHOp::OpEqualFace,             SMESH_Actor::eCoincidentElems2D );
     ActionControl.Bind( SMESHOp::OpAspectRatio3D,         SMESH_Actor::eAspectRatio3D );
+    ActionControl.Bind( SMESHOp::OpWarping3D,             SMESH_Actor::eWarping3D );
     ActionControl.Bind( SMESHOp::OpVolume,                SMESH_Actor::eVolume3D );
+    ActionControl.Bind( SMESHOp::OpScaledJacobian,        SMESH_Actor::eScaledJacobian );
     ActionControl.Bind( SMESHOp::OpMaxElementLength3D,    SMESH_Actor::eMaxElementLength3D );
     ActionControl.Bind( SMESHOp::OpBareBorderVolume,      SMESH_Actor::eBareBorderVolume );
     ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
@@ -1853,7 +1828,7 @@ namespace
                 if ( anActor->GetControlMode() != aControl )
                   anActor->SetControlMode( aControl );
                 QString functorName = functorToString( anActor->GetFunctor() );
-                int anEntitiesCount = anActor->GetNumberControlEntities();
+                smIdType anEntitiesCount = anActor->GetNumberControlEntities();
                 if (anEntitiesCount >= 0)
                   functorName = functorName + ": " + QString::number(anEntitiesCount);
                 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
@@ -2121,6 +2096,19 @@ void SMESHGUI::OnEditDelete()
         aStudyBuilder->RemoveObjectWithChildren( SO );
       }
       else {// default action: remove SObject from the study
+        // Find Sub-Meshes and Group and delete corresopning visual objects and actors
+        _PTR(ChildIterator) it1 = aStudy->NewChildIterator(SO);
+        for (it1->InitEx(false); it1->More(); it1->Next()) {
+          _PTR(SObject) SObj = it1->Value();
+          if (!SObj) continue;
+          if (SObj->FindAttribute(anAttr, "AttributeIOR")) {
+            SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(SMESH::SObjectToObject(SObj));
+            SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow(SMESH::SObjectToObject(SObj));
+            if (!aGroup->_is_nil() || !aSubMesh->_is_nil()) {
+              SMESH::RemoveVisualObjectWithActors(SObj->GetID().c_str(), true);
+            }
+          }
+        }
         // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
         //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
         //op->start();
@@ -2162,15 +2150,8 @@ SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
   if ( CORBA::is_nil( myComponentSMESH ) )
   {
     CORBA::Boolean anIsEmbeddedMode;
-    SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
-    if( dynamic_cast<SALOME_NamingService *>(ns) )
-      myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
-    else
-      {
-        Engines::EngineComponent_var comp = RetrieveSMESHInstance();
-        myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
-      }
-    
+    myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
+
     //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
 
     //  0019923: EDF 765 SMESH : default values of hypothesis
@@ -2261,7 +2242,7 @@ bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
   bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
 
-  SMESH::long_array_var info = theMesh->GetMeshInfo();
+  SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
   long nbOdElems = info[SMDSEntity_0D];
   long nbEdges   = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
   long nbFaces   = info[SMDSEntity_Triangle]   + info[SMDSEntity_Quad_Triangle]   + info[SMDSEntity_BiQuad_Triangle] +
@@ -2590,14 +2571,12 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
   case SMESHOp::OpImportMED:
   case SMESHOp::OpImportSTL:
   case SMESHOp::OpImportCGNS:
-  case SMESHOp::OpImportSAUV:
   case SMESHOp::OpImportGMF:
   case SMESHOp::OpPopupImportDAT:
   case SMESHOp::OpPopupImportUNV:
   case SMESHOp::OpPopupImportMED:
   case SMESHOp::OpPopupImportSTL:
   case SMESHOp::OpPopupImportCGNS:
-  case SMESHOp::OpPopupImportSAUV:
   case SMESHOp::OpPopupImportGMF:
     {
       if(isStudyLocked()) break;
@@ -2628,14 +2607,12 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
   case SMESHOp::OpExportUNV:
   case SMESHOp::OpExportSTL:
   case SMESHOp::OpExportCGNS:
-  case SMESHOp::OpExportSAUV:
   case SMESHOp::OpExportGMF:
   case SMESHOp::OpPopupExportDAT:
   case SMESHOp::OpPopupExportMED:
   case SMESHOp::OpPopupExportUNV:
   case SMESHOp::OpPopupExportSTL:
   case SMESHOp::OpPopupExportCGNS:
-  case SMESHOp::OpPopupExportSAUV:
   case SMESHOp::OpPopupExportGMF:
     {
       ::ExportMeshToFile(theCommandID);
@@ -3056,11 +3033,36 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
       ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
       break;
     }
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+  case SMESHOp::OpHomardAdapt:
+    {
+      if ( isStudyLocked() )
+        break;
+      EmitSignalDeactivateDialog();
+
+      SALOME::GenericObj_wrap< SMESHHOMARD::HOMARD_Gen > homardGen;
+      try {
+        homardGen = GetSMESHGen()->CreateHOMARD_ADAPT();
+      }
+      catch ( const SALOME::SALOME_Exception& S_ex ) {
+        SUIT_MessageBox::critical(SMESHGUI::desktop(),
+                                  QObject::tr("SMESH_ERROR"),
+                                  QObject::tr(S_ex.details.text.in()));
+      }
+      if (!homardGen->_is_nil()) {
+        SMESHGUI_HomardAdaptDlg *aDlg = new SMESHGUI_HomardAdaptDlg(homardGen);
+        aDlg->show();
+      }
+      break;
+    }
 #endif
   // Adaptation - end
   case SMESHOp::OpSplitBiQuadratic:
   case SMESHOp::OpConvertMeshToQuadratic:
+  case SMESHOp::OpCreateDualMesh:
   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
+  case SMESHOp::OpCreate2DElements: // create full 2D mesh from 3D
   case SMESHOp::OpReorientFaces:
   case SMESHOp::OpCreateGeometryGroup:
     {
@@ -3128,10 +3130,10 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
               try {
                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
                 // get submesh elements list by types
-                SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
-                SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
-                SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
-                SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
+                SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
+                SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
+                SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
+                SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
                 // create group for each type o elements
                 QString aName = IObject->getName();
                 QStringList anEntryList;
@@ -3560,6 +3562,14 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
       }
       break;
     }
+  case SMESHOp::OpRemoveNodeWithReconn:
+    {
+      if(isStudyLocked()) break;
+      if ( warnOnGeomModif() )
+        break; // action forbidden as geometry modified
+      startOperation( SMESHOp::OpRemoveNodeWithReconn );
+      break;
+    }
   case SMESHOp::OpRemoveElements:                                    // REMOVES ELEMENTS
     {
       if(isStudyLocked()) break;
@@ -3639,7 +3649,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
             try {
               SUIT_OverrideCursor wc;
               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
-              int removed = aMeshEditor->RemoveOrphanNodes();
+              smIdType removed = aMeshEditor->RemoveOrphanNodes();
               SUIT_MessageBox::information(SMESHGUI::desktop(),
                                            tr("SMESH_INFORMATION"),
                                            tr("NB_NODES_REMOVED").arg(removed));
@@ -3818,6 +3828,24 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     startOperation( SMESHOp::OpMoveNode );
     break;
 
+  case SMESHOp::OpMoveNodeInteractive:
+    if ( warnOnGeomModif() )
+      break; // action forbidden as geometry modified
+    startOperation( SMESHOp::OpMoveNodeInteractive );
+    break;
+
+  case SMESHOp::OpSplitEdgeInteract:
+    if ( warnOnGeomModif() )
+      break; // action forbidden as geometry modified
+    startOperation( SMESHOp::OpSplitEdgeInteract );
+    break;
+
+  case SMESHOp::OpSplitFaceInteract:
+    if ( warnOnGeomModif() )
+      break; // action forbidden as geometry modified
+    startOperation( SMESHOp::OpSplitFaceInteract );
+    break;
+
   case SMESHOp::OpDuplicateNodes:
     {
       if(isStudyLocked()) break;
@@ -3881,7 +3909,9 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
   case SMESHOp::OpMaxElementLength2D:
   case SMESHOp::OpEqualFace:
   case SMESHOp::OpAspectRatio3D:
+  case SMESHOp::OpWarping3D:
   case SMESHOp::OpVolume:
+  case SMESHOp::OpScaledJacobian:
   case SMESHOp::OpMaxElementLength3D:
   case SMESHOp::OpBareBorderVolume:
   case SMESHOp::OpOverConstrainedVolume:
@@ -4105,7 +4135,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
 #endif
-  createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
   createSMESHAction( SMESHOp::OpImportGMF,  "IMPORT_GMF"  );
   createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
   createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
@@ -4113,7 +4142,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
 #endif
-  createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
   createSMESHAction( SMESHOp::OpPopupImportGMF,  "IMPORT_GMF"  );
 
   createSMESHAction( SMESHOp::OpExportDAT,  "DAT" );
@@ -4123,7 +4151,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
 #endif
-  createSMESHAction( SMESHOp::OpExportSAUV,     "SAUV");
   createSMESHAction( SMESHOp::OpExportGMF,      "GMF" );
   createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
   createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
@@ -4132,7 +4159,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
 #endif
-  createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
   createSMESHAction( SMESHOp::OpPopupExportGMF,  "GMF" );
   createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
   createSMESHAction( SMESHOp::OpDelete,          "DELETE", "ICON_DELETE", Qt::Key_Delete );
@@ -4192,11 +4218,13 @@ void SMESHGUI::initialize( CAM_Application* app )
   createSMESHAction( SMESHOp::OpMaxElementLength2D,    "MAX_ELEMENT_LENGTH_2D",   "ICON_MAX_ELEMENT_LENGTH_2D",   0, true );
   createSMESHAction( SMESHOp::OpEqualFace,             "EQUAL_FACE",              "ICON_EQUAL_FACE",    0, true );
   createSMESHAction( SMESHOp::OpAspectRatio3D,         "ASPECT_3D",               "ICON_ASPECT_3D",     0, true );
+  createSMESHAction( SMESHOp::OpWarping3D,             "WARP_3D",                 "ICON_WARP",          0, true);
   createSMESHAction( SMESHOp::OpVolume,                "VOLUME_3D",               "ICON_VOLUME_3D",     0, true );
   createSMESHAction( SMESHOp::OpMaxElementLength3D,    "MAX_ELEMENT_LENGTH_3D",   "ICON_MAX_ELEMENT_LENGTH_3D",   0, true );
   createSMESHAction( SMESHOp::OpBareBorderVolume,      "BARE_BORDER_VOLUME",      "ICON_BARE_BORDER_VOLUME",      0, true );
   createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
   createSMESHAction( SMESHOp::OpEqualVolume,           "EQUAL_VOLUME",            "ICON_EQUAL_VOLUME",  0, true );
+  createSMESHAction( SMESHOp::OpScaledJacobian,        "SCALED_JACOBIAN",         "ICON_SCALED_JACOBIAN",         0, true );
   createSMESHAction( SMESHOp::OpOverallMeshQuality,    "OVERALL_MESH_QUALITY",    "ICON_OVL_MESH_QUALITY" );
 
   createSMESHAction( SMESHOp::OpNode,                   "NODE",            "ICON_DLG_NODE" );
@@ -4229,6 +4257,7 @@ void SMESHGUI::initialize( CAM_Application* app )
   createSMESHAction( SMESHOp::OpRemoveNodes,       "REMOVE_NODES",          "ICON_DLG_REM_NODE" );
   createSMESHAction( SMESHOp::OpRemoveElements,    "REMOVE_ELEMENTS",       "ICON_DLG_REM_ELEMENT" );
   createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES",   "ICON_DLG_REM_ORPHAN_NODES" );
+  createSMESHAction( SMESHOp::OpRemoveNodeWithReconn, "REMOVE_NODE_RECON",  "ICON_REM_NODE_RECON" );
   createSMESHAction( SMESHOp::OpClearMesh,         "CLEAR_MESH",            "ICON_CLEAR_MESH" );
 
   //createSMESHAction( SMESHOp::OpRenumberingNodes,    "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
@@ -4243,6 +4272,9 @@ void SMESHGUI::initialize( CAM_Application* app )
   createSMESHAction( SMESHOp::OpMergeNodes,             "MERGE",           "ICON_SMESH_MERGE_NODES" );
   createSMESHAction( SMESHOp::OpMergeElements,          "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
   createSMESHAction( SMESHOp::OpMoveNode,               "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
+  createSMESHAction( SMESHOp::OpMoveNodeInteractive,    "MOVE_NODE_INTRCT","ICON_DLG_MOVE_NODE_INTERACTIVE" );
+  createSMESHAction( SMESHOp::OpSplitEdgeInteract,  "SPLIT_DIAG_INTRC","ICON_SPLIT_DIAG_INTERACTIVE" );
+  createSMESHAction( SMESHOp::OpSplitFaceInteract,      "SPLIT_FACE_INTRC","ICON_SPLIT_FACE_INTERACTIVE" );
   createSMESHAction( SMESHOp::OpDuplicateNodes,         "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
   createSMESHAction( SMESHOp::OpDiagonalInversion,      "INV",             "ICON_DLG_MESH_DIAGONAL" );
   createSMESHAction( SMESHOp::OpUnionOfTwoTriangle,     "UNION2",          "ICON_UNION2TRI" );
@@ -4258,7 +4290,9 @@ void SMESHGUI::initialize( CAM_Application* app )
   createSMESHAction( SMESHOp::OpRevolution,             "REVOLUTION",      "ICON_REVOLUTION" );
   createSMESHAction( SMESHOp::OpPatternMapping,         "MAP",             "ICON_MAP" );
   createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
+  createSMESHAction( SMESHOp::OpCreateDualMesh,         "CREATE_DUAL_MESH","ICON_CREATE_DUAL_MESH" );
   createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
+  createSMESHAction( SMESHOp::OpCreate2DElements,    "2D_FROM_3D_ELEMENTS","ICON_2D_FROM_3D_ELEMENTS" );
 
   createSMESHAction( SMESHOp::OpReset,               "RESET" );
   createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
@@ -4298,6 +4332,9 @@ void SMESHGUI::initialize( CAM_Application* app )
   // Adaptation - begin
 #ifndef DISABLE_MG_ADAPT
   createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+  createSMESHAction( SMESHOp::OpHomardAdapt, "HOMARD_ADAPT", "ICON_HOMARD_ADAPT" );
 #endif
   // Adaptation - end
 
@@ -4327,9 +4364,9 @@ void SMESHGUI::initialize( CAM_Application* app )
                << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
                << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
                << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace                // face controls
-               << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
+               << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume << SMESHOp::OpWarping3D
                << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
-               << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume;           // volume controls
+               << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume << SMESHOp::OpScaledJacobian; // volume controls
   QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
   aCtrlGroup->setExclusive( true );
   for( int i = 0; i < aCtrlActions.size(); i++ )
@@ -4342,7 +4379,7 @@ void SMESHGUI::initialize( CAM_Application* app )
       meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
       ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
       modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
-#ifndef DISABLE_MG_ADAPT
+#if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
       adaptId   = createMenu( tr( "MEN_ADAPT" ),   -1, 80, 10 ),
 #endif
       measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
@@ -4371,7 +4408,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createMenu( SMESHOp::OpImportCGNS, importId, -1 );
 #endif
-  createMenu( SMESHOp::OpImportSAUV, importId, -1 );
   createMenu( SMESHOp::OpImportGMF,  importId, -1 );
   createMenu( SMESHOp::OpExportDAT,  exportId, -1 );
   createMenu( SMESHOp::OpExportMED,  exportId, -1 );
@@ -4380,7 +4416,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
 #endif
-  createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
   createMenu( SMESHOp::OpExportGMF,  exportId, -1 );
   createMenu( separator(), fileId, 10 );
 
@@ -4393,6 +4428,7 @@ void SMESHGUI::initialize( CAM_Application* app )
   createMenu( SMESHOp::OpEditMeshOrSubMesh,    meshId, -1 );
   createMenu( SMESHOp::OpBuildCompoundMesh,    meshId, -1 );
   createMenu( SMESHOp::OpCopyMesh,             meshId, -1 );
+  createMenu( SMESHOp::OpCreateDualMesh,       meshId, -1 );
   createMenu( separator(),                     meshId, -1 );
   createMenu( SMESHOp::OpCompute,              meshId, -1 );
   createMenu( SMESHOp::OpPreCompute,           meshId, -1 );
@@ -4441,11 +4477,13 @@ void SMESHGUI::initialize( CAM_Application* app )
   createMenu( SMESHOp::OpEqualFace,             faceId,   -1 );
   createMenu( SMESHOp::OpDeflection2D,          faceId,   -1 );
   createMenu( SMESHOp::OpAspectRatio3D,         volumeId, -1 );
+  createMenu( SMESHOp::OpWarping3D,             volumeId, -1 );
   createMenu( SMESHOp::OpVolume,                volumeId, -1 );
   createMenu( SMESHOp::OpMaxElementLength3D,    volumeId, -1 );
   createMenu( SMESHOp::OpBareBorderVolume,      volumeId, -1 );
   createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
   createMenu( SMESHOp::OpEqualVolume,           volumeId, -1 );
+  createMenu( SMESHOp::OpScaledJacobian,        volumeId, -1 );
   createMenu( separator(),                      ctrlId,   -1 );
   createMenu( SMESHOp::OpReset,                 ctrlId,   -1 );
   createMenu( separator(),                      ctrlId,   -1 );
@@ -4478,14 +4516,18 @@ void SMESHGUI::initialize( CAM_Application* app )
   createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
   createMenu( SMESHOp::OpQuadraticHexahedron,    addId, -1 );
   createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
-
-  createMenu( SMESHOp::OpRemoveNodes,       removeId, -1 );
-  createMenu( SMESHOp::OpRemoveElements,    removeId, -1 );
-  createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
-  createMenu( separator(),                  removeId, -1 );
-  createMenu( SMESHOp::OpDeleteGroup,       removeId, -1 );
-  createMenu( separator(),                  removeId, -1 );
-  createMenu( SMESHOp::OpClearMesh,         removeId, -1 );
+  createMenu( separator(),                       addId, -1 );
+  createMenu( SMESHOp::OpSplitEdgeInteract,      addId, -1 );
+  createMenu( SMESHOp::OpSplitFaceInteract,      addId, -1 );
+
+  createMenu( SMESHOp::OpRemoveNodes,          removeId, -1 );
+  createMenu( SMESHOp::OpRemoveElements,       removeId, -1 );
+  createMenu( SMESHOp::OpRemoveOrphanNodes,    removeId, -1 );
+  createMenu( SMESHOp::OpRemoveNodeWithReconn, removeId, -1 );
+  createMenu( separator(),                     removeId, -1 );
+  createMenu( SMESHOp::OpDeleteGroup,          removeId, -1 );
+  createMenu( separator(),                     removeId, -1 );
+  createMenu( SMESHOp::OpClearMesh,            removeId, -1 );
 
   //createMenu( SMESHOp::OpRenumberingNodes,    renumId, -1 );
   //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
@@ -4502,6 +4544,7 @@ void SMESHGUI::initialize( CAM_Application* app )
 
   createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
   createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
+  createMenu( SMESHOp::OpCreate2DElements,       modifyId, -1 );
   createMenu( SMESHOp::OpExtrusion,              modifyId, -1 );
   createMenu( SMESHOp::OpExtrusionAlongAPath,    modifyId, -1 );
   createMenu( SMESHOp::OpRevolution,             modifyId, -1 );
@@ -4520,6 +4563,9 @@ void SMESHGUI::initialize( CAM_Application* app )
   // Adaptation - begin
 #ifndef DISABLE_MG_ADAPT
   createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+  createMenu( SMESHOp::OpHomardAdapt, adaptId, -1 );
 #endif
   // Adaptation - end
 
@@ -4591,11 +4637,13 @@ void SMESHGUI::initialize( CAM_Application* app )
 
   int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
   createTool( SMESHOp::OpAspectRatio3D,         ctrl3dTb );
+  createTool( SMESHOp::OpWarping3D,             ctrl3dTb );
   createTool( SMESHOp::OpVolume,                ctrl3dTb );
   createTool( SMESHOp::OpMaxElementLength3D,    ctrl3dTb );
   createTool( SMESHOp::OpBareBorderVolume,      ctrl3dTb );
   createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
   createTool( SMESHOp::OpEqualVolume,           ctrl3dTb );
+  createTool( SMESHOp::OpScaledJacobian,        ctrl3dTb );
 
   int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
   createTool( SMESHOp::OpNode,              addElemTb );
@@ -4651,6 +4699,7 @@ void SMESHGUI::initialize( CAM_Application* app )
   int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
   createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
   createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
+  createTool( SMESHOp::OpCreate2DElements,       modifyTb );
   createTool( SMESHOp::OpExtrusion,              modifyTb );
   createTool( SMESHOp::OpExtrusionAlongAPath,    modifyTb );
   createTool( SMESHOp::OpRevolution,             modifyTb );
@@ -4666,10 +4715,21 @@ void SMESHGUI::initialize( CAM_Application* app )
   createTool( SMESHOp::OpSmoothing,              modifyTb );
   createTool( SMESHOp::OpPatternMapping,         modifyTb );
 
+  int interactTb = createTool( tr( "TB_INTERACT" ), QString( "SMESHInteractiveToolbar" ) ) ;
+  createTool( SMESHOp::OpMoveNodeInteractive,   interactTb );
+  createTool( SMESHOp::OpRemoveNodeWithReconn,  interactTb );
+  createTool( SMESHOp::OpSplitEdgeInteract, interactTb );
+  createTool( SMESHOp::OpSplitFaceInteract,     interactTb );
+
   // Adaptation - begin
-#ifndef DISABLE_MG_ADAPT
+#if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
   int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
+#endif
+#ifndef DISABLE_MG_ADAPT
   createTool( SMESHOp::OpMGAdapt, adaptTb );
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+  createTool( SMESHOp::OpHomardAdapt, adaptTb );
 #endif
   // Adaptation - end
 
@@ -4754,11 +4814,14 @@ void SMESHGUI::initialize( CAM_Application* app )
   createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
 
   // Adaptation - begin
-#ifndef DISABLE_MG_ADAPT
   popupMgr()->insert( separator(), -1, 0 );
+#ifndef DISABLE_MG_ADAPT
   createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
-  popupMgr()->insert( separator(), -1, 0 );
 #endif
+#ifndef DISABLE_HOMARD_ADAPT
+  createPopupItem( SMESHOp::OpHomardAdapt, OB, mesh );
+#endif
+  popupMgr()->insert( separator(), -1, 0 );
   // Adaptation - end
 
   QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
@@ -4773,7 +4836,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
 #endif
-  createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
   createPopupItem( SMESHOp::OpPopupExportGMF,  OB, mesh_group, only_one_non_empty, anId );
   createPopupItem( SMESHOp::OpPopupExportDAT,  OB, mesh_group, only_one_non_empty, anId );
 
@@ -4784,7 +4846,6 @@ void SMESHGUI::initialize( CAM_Application* app )
 #ifdef WITH_CGNS
   createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
 #endif
-  createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
   createPopupItem( SMESHOp::OpPopupImportGMF,  OB, smesh, "", anId );
   createPopupItem( SMESHOp::OpPopupImportDAT,  OB, smesh, "", anId );
   popupMgr()->insert( separator(), -1, 0 );
@@ -5041,6 +5102,10 @@ void SMESHGUI::initialize( CAM_Application* app )
   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
   popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
 
+  popupMgr()->insert ( action( SMESHOp::OpWarping3D ), aSubId, -1 );
+  popupMgr()->setRule( action( SMESHOp::OpWarping3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
+  popupMgr()->setRule( action( SMESHOp::OpWarping3D), "controlMode = 'eWarping3D'", QtxPopupMgr::ToggleRule );
+
   popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
   popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
   popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
@@ -5061,6 +5126,10 @@ void SMESHGUI::initialize( CAM_Application* app )
   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
   popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
 
+  popupMgr()->insert ( action( SMESHOp::OpScaledJacobian  ), aSubId, -1 );
+  popupMgr()->setRule( action( SMESHOp::OpScaledJacobian ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
+  popupMgr()->setRule( action( SMESHOp::OpScaledJacobian ), "controlMode = 'eScaledJacobian'", QtxPopupMgr::ToggleRule );
+
   popupMgr()->insert( separator(), anId, -1 );
 
   popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
@@ -5192,7 +5261,6 @@ bool SMESHGUI::activateModule( SUIT_Study* study )
         << wrap("MED", "li")
         << wrap("STL", "li")
         << wrap("CGNS", "li")
-        << wrap("SAUV", "li")
         << wrap("GMF", "li");
   lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
   items.clear();
@@ -5471,6 +5539,7 @@ void SMESHGUI::createPreferences()
   setPreferenceProperty( exportgroup, "columns", 2 );
   addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
   addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
+  addPreference( tr( "PREF_MED_SAVE_NUMS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "med_save_numbers" );
   int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
   setPreferenceProperty( zTol, "precision", 10 );
   setPreferenceProperty( zTol, "min", 0.0000000001 );
@@ -5628,23 +5697,23 @@ void SMESHGUI::createPreferences()
   int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
                              LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
   /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
-                             LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
-  double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
-                             LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
-  double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
-                             LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
-  int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
-                             LightApp_Preferences::IntSpin, "SMESH", "element_width");
-  int outW  = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
-                             LightApp_Preferences::IntSpin, "SMESH", "outline_width");
-  int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
-                             LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
+     LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
+  int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
+                                   LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
+  int ballScale    = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
+                                   LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
+  int elemW        = addPreference(tr("PREF_WIDTH"), elemGroup,
+                                   LightApp_Preferences::IntSpin, "SMESH", "element_width");
+  int outW         = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
+                                   LightApp_Preferences::IntSpin, "SMESH", "outline_width");
+  int shrink       = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
+                                   LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
 
   setPreferenceProperty( size0d, "min", 1 );
   setPreferenceProperty( size0d, "max", 10 );
 
- // setPreferenceProperty( ballSize, "min", 1 );
- // setPreferenceProperty( ballSize, "max", 10 );
+  // setPreferenceProperty( ballSize, "min", 1 );
+  // setPreferenceProperty( ballSize, "max", 10 );
 
   setPreferenceProperty( ballDiameter, "min", 1e-7 );
   setPreferenceProperty( ballDiameter, "max", 1e9 );
@@ -5822,8 +5891,8 @@ void SMESHGUI::createPreferences()
 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
 {
   if ( sect=="SMESH" ) {
-    float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
-    float aTol = 1.00000009999999;
+    double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
+    double aTol = 1.00000009999999;
     std::string aWarning;
     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
 
@@ -5988,6 +6057,12 @@ LightApp_Operation* SMESHGUI::createOperation( const int id ) const
   case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
     op = new SMESHGUI_Make2DFrom3DOp();
     break;
+  case SMESHOp::OpCreateDualMesh:
+    op = new SMESHGUI_CreateDualMeshOp();
+    break;
+  case SMESHOp::OpCreate2DElements:
+    op = new SMESHGUI_MakeFull2DFrom3DOp();
+    break;
   case SMESHOp::OpReorientFaces:
     op = new SMESHGUI_ReorientFacesOp();
     break;
@@ -6027,6 +6102,18 @@ LightApp_Operation* SMESHGUI::createOperation( const int id ) const
   case SMESHOp::OpMoveNode: // Make mesh pass through point
     op = new SMESHGUI_MakeNodeAtPointOp();
     break;
+  case SMESHOp::OpMoveNodeInteractive: // Make mesh pass through point / by mouse
+    op = new SMESHGUI_MakeNodeAtPointOp( 2 );
+    break;
+  case SMESHOp::OpRemoveNodeWithReconn:
+    op = new SMESHGUI_RemoveNodeReconnectionOp();
+    break;
+  case SMESHOp::OpSplitEdgeInteract:
+    op = new SMESHGUI_AddNodeOnSegmentOp();
+    break;
+  case SMESHOp::OpSplitFaceInteract:
+    op = new SMESHGUI_AddNodeOnFaceOp();
+    break;
   case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
     op = new SMESHGUI_Add0DElemsOnAllNodesOp();
     break;