src/SMESHGUI/SMESHGUI.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SMESHGUI.cxx
  23 //  Author : Nicolas REJNERI, Open CASCADE S.A.S.
  24
  25 #include <Standard_math.hxx>  // E.A. must be included before Python.h to fix compilation on windows
  26 #ifdef HAVE_FINITE
  27 #undef HAVE_FINITE            // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
  28 #endif
  29 #include "Python.h"
  30
  31 //  SMESH includes
  32 #include "SMESHGUI.h"
  33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
  34 #include "SMESHGUI_AddMeshElementDlg.h"
  35 #include "SMESHGUI_AddQuadraticElementDlg.h"
  36 #include "SMESHGUI_BuildCompoundDlg.h"
  37 #include "SMESHGUI_ClippingDlg.h"
  38 #include "SMESHGUI_ComputeDlg.h"
  39 #include "SMESHGUI_ConvToQuadOp.h"
  40 #include "SMESHGUI_CopyMeshDlg.h"
  41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
  42 #include "SMESHGUI_DeleteGroupDlg.h"
  43 #include "SMESHGUI_Displayer.h"
  44 #include "SMESHGUI_DuplicateNodesDlg.h"
  45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
  46 #include "SMESHGUI_ExtrusionDlg.h"
  47 #include "SMESHGUI_FieldSelectorWdg.h"
  48 #include "SMESHGUI_FileInfoDlg.h"
  49 #include "SMESHGUI_FileValidator.h"
  50 #include "SMESHGUI_FilterDlg.h"
  51 #include "SMESHGUI_FilterLibraryDlg.h"
  52 #include "SMESHGUI_FindElemByPointDlg.h"
  53 #include "SMESHGUI_GroupDlg.h"
  54 #include "SMESHGUI_GroupOnShapeDlg.h"
  55 #include "SMESHGUI_GroupOpDlg.h"
  56 #include "SMESHGUI_Hypotheses.h"
  57 #include "SMESHGUI_Make2DFrom3DOp.h"
  58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
  59 #include "SMESHGUI_Measurements.h"
  60 #include "SMESHGUI_MergeDlg.h"
  61 #include "SMESHGUI_MeshInfo.h"
  62 #include "SMESHGUI_MeshOp.h"
  63 #include "SMESHGUI_MeshOrderOp.h"
  64 #include "SMESHGUI_MeshPatternDlg.h"
  65 #include "SMESHGUI_MultiEditDlg.h"
  66 #include "SMESHGUI_NodesDlg.h"
  67 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
  68 #include "SMESHGUI_PropertiesDlg.h"
  69 #include "SMESHGUI_RemoveElementsDlg.h"
  70 #include "SMESHGUI_RemoveNodesDlg.h"
  71 #include "SMESHGUI_RenumberingDlg.h"
  72 #include "SMESHGUI_ReorientFacesDlg.h"
  73 #include "SMESHGUI_RevolutionDlg.h"
  74 #include "SMESHGUI_RotationDlg.h"
  75 #include "SMESHGUI_ScaleDlg.h"
  76 #include "SMESHGUI_Selection.h"
  77 #include "SMESHGUI_SewingDlg.h"
  78 #include "SMESHGUI_SingleEditDlg.h"
  79 #include "SMESHGUI_SmoothingDlg.h"
  80 #include "SMESHGUI_SymmetryDlg.h"
  81 #include "SMESHGUI_TranslationDlg.h"
  82 #include "SMESHGUI_TransparencyDlg.h"
  83
  84 #include "SMESHGUI_FilterUtils.h"
  85 #include "SMESHGUI_GroupUtils.h"
  86 #include "SMESHGUI_HypothesesUtils.h"
  87 #include "SMESHGUI_MeshUtils.h"
  88 #include "SMESHGUI_PatternUtils.h"
  89 #include "SMESHGUI_Utils.h"
  90 #include "SMESHGUI_VTKUtils.h"
  91
  92 #include <SMESH_version.h>
  93
  94 #include "SMESH_ControlsDef.hxx"
  95 #include <SMESH_Actor.h>
  96 #include <SMESH_ActorUtils.h>
  97 #include <SMESH_Client.hxx>
  98 #include <SMESH_ScalarBarActor.h>
  99 #include <SMESH_TypeFilter.hxx>
 100
 101 // SALOME GUI includes
 102 #include <SalomeApp_Application.h>
 103 #include <SalomeApp_CheckFileDlg.h>
 104 #include <SalomeApp_DataObject.h>
 105 #include <SalomeApp_Study.h>
 106 #include <SalomeApp_Tools.h>
 107
 108 #include <LightApp_DataOwner.h>
 109 #include <LightApp_NameDlg.h>
 110 #include <LightApp_Preferences.h>
 111 #include <LightApp_SelectionMgr.h>
 112 #include <LightApp_UpdateFlags.h>
 113
 114 #include <SVTK_ViewManager.h>
 115 #include <SVTK_ViewModel.h>
 116 #include <SVTK_ViewWindow.h>
 117
 118 #include <VTKViewer_Algorithm.h>
 119
 120 #include <PyInterp_Interp.h>
 121
 122 #include <SUIT_Desktop.h>
 123 #include <SUIT_FileDlg.h>
 124 #include <SUIT_MessageBox.h>
 125 #include <SUIT_OverrideCursor.h>
 126 #include <SUIT_ResourceMgr.h>
 127 #include <SUIT_Session.h>
 128
 129 #include <QtxPopupMgr.h>
 130 #include <QtxFontEdit.h>
 131
 132 #include <SALOME_ListIO.hxx>
 133 #include <SALOME_ListIteratorOfListIO.hxx>
 134
 135 #ifndef DISABLE_PLOT2DVIEWER
 136 #include <SPlot2d_ViewModel.h>
 137 #include <SPlot2d_Histogram.h>
 138 #endif
 139
 140 // IDL includes
 141 #include <SALOMEconfig.h>
 142 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
 143 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
 144 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
 145
 146 // Qt includes
 147 // #define       INCLUDE_MENUITEM_DEF // VSR commented ????????
 148 #include <QApplication>
 149 #include <QMenu>
 150 #include <QTextStream>
 151
 152 // BOOST includes
 153 #include <boost/shared_ptr.hpp>
 154
 155 // VTK includes
 156 #include <vtkCallbackCommand.h>
 157 #include <vtkCamera.h>
 158 #include <vtkLookupTable.h>
 159 #include <vtkPlane.h>
 160 #include <vtkRenderer.h>
 161
 162 // SALOME KERNEL includes
 163 #include <SALOMEDSClient_ClientFactory.hxx>
 164 #include <SALOMEDSClient_IParameters.hxx>
 165 #include <SALOMEDSClient_SComponent.hxx>
 166 #include <SALOMEDSClient_StudyBuilder.hxx>
 167 #include <SALOMEDS_Study.hxx>
 168 #include <SALOMEDS_SObject.hxx>
 169
 170 // OCCT includes
 171 #include <Standard_ErrorHandler.hxx>
 172 #include <NCollection_DataMap.hxx>
 173
 174 #include <Basics_Utils.hxx>
 175
 176 //To disable automatic genericobj management, the following line should be commented.
 177 //Otherwise, it should be uncommented.
 178 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
 179 #define WITHGENERICOBJ
 180
 181 // Below macro, when uncommented, switches on simplified (more performant) algorithm
 182 // of auto-color picking up
 183 #define SIMPLE_AUTOCOLOR
 184
 185 namespace
 186 {
 187   // Declarations
 188   //=============================================================
 189   void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
 190                             int theCommandID);
 191
 192   void ExportMeshToFile(int theCommandID);
 193
 194   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
 195
 196   void SetDisplayEntity(int theCommandID);
 197
 198   void Control( int theCommandID );
 199
 200   // Definitions
 201   //================================================================================
 202   /*!
 203    * \brief Reads meshes from file
 204    */
 205   //================================================================================
 206
 207   void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
 208                              int theCommandID )
 209   {
 210     QStringList filter;
 211     std::string myExtension;
 212
 213     if ( theCommandID == 113 ) {
 214       filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
 215       filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
 216     }
 217     else if ( theCommandID == 112 ) {
 218       filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
 219     }
 220     else if ( theCommandID == 111 ) {
 221       filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
 222     }
 223     else if ( theCommandID == 115 ) {
 224       filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
 225     }
 226     else if ( theCommandID == 116 ) {
 227       filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 228     }
 229     else if ( theCommandID == 117 ) {
 230       filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
 231       filter.append( QObject::tr( "All files (*)" ) );
 232     }
 233     else if ( theCommandID == 118 ) {
 234       filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"  );
 235       filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
 236     }
 237
 238     QString anInitialPath = "";
 239     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 240       anInitialPath = QDir::currentPath();
 241
 242     QStringList filenames;
 243     bool toCreateGroups = true;
 244
 245     // if ( theCommandID == 118 ) { // GMF
 246     //   SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
 247     //     ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
 248     //   fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
 249     //   fd->setNameFilters( filter );
 250     //   fd->SetChecked( true );
 251     //   if ( fd->exec() )
 252     //     filenames << fd->selectedFile();
 253     //   toCreateGroups = fd->IsChecked();
 254
 255     //   delete fd;
 256     // }
 257     // else
 258     {
 259       filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
 260                                                   anInitialPath,
 261                                                   filter,
 262                                                   QObject::tr( "SMESH_IMPORT_MESH" ) );
 263     }
 264     if ( filenames.count() > 0 ) {
 265       SUIT_OverrideCursor wc;
 266       _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
 267
 268       QStringList errors;
 269       QStringList anEntryList;
 270       bool isEmpty = false;
 271       for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
 272         QString filename = *it;
 273         SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
 274         try {
 275           switch ( theCommandID ) {
 276           case 111:
 277             {
 278               // DAT format (currently unsupported)
 279               errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 280                              arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
 281               break;
 282             }
 283           case 112:
 284             {
 285               // UNV format
 286               aMeshes->length( 1 );
 287               aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
 288               if ( aMeshes[0]->_is_nil() )
 289                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 290                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 291               break;
 292             }
 293           case 113:
 294             {
 295               // MED format
 296               SMESH::DriverMED_ReadStatus res;
 297               aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
 298               if ( res != SMESH::DRS_OK ) {
 299                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 300                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 301               }
 302               break;
 303             }
 304           case 115:
 305             {
 306               // STL format
 307               aMeshes->length( 1 );
 308               aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
 309               if ( aMeshes[0]->_is_nil() ) {
 310                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 311                                arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 312               }
 313               break;
 314             }
 315           case 116:
 316             {
 317               // CGNS format
 318               SMESH::DriverMED_ReadStatus res;
 319               aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
 320               if ( res != SMESH::DRS_OK ) {
 321                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 322                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 323               }
 324               break;
 325             }
 326           case 117:
 327             {
 328               // SAUV format
 329               SMESH::DriverMED_ReadStatus res;
 330               aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
 331               if ( res != SMESH::DRS_OK ) {
 332                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 333                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
 334               }
 335               break;
 336             }
 337           case 118:
 338             {
 339               // GMF format
 340               SMESH::ComputeError_var res;
 341               aMeshes->length( 1 );
 342               aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
 343                                                                   toCreateGroups,
 344                                                                   res.out() );
 345               if ( res->code != SMESH::DRS_OK ) {
 346                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 347                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
 348                 if ( strlen( res->comment.in() ) > 0 ) {
 349                   errors.back() += ": ";
 350                   errors.back() += res->comment.in();
 351                 }
 352               }
 353               break;
 354             }
 355           }
 356         }
 357         catch ( const SALOME::SALOME_Exception& S_ex ) {
 358           errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
 359                          arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
 360         }
 361
 362         for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
 363           _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
 364           if ( aMeshSO ) {
 365             _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
 366             _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
 367             aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
 368             if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
 369               SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
 370
 371             anEntryList.append( aMeshSO->GetID().c_str() );
 372           }
 373           else {
 374             isEmpty = true;
 375           }
 376         }
 377       }
 378
 379       // update Object browser
 380       SMESHGUI::GetSMESHGUI()->updateObjBrowser();
 381
 382       // browse to the published meshes
 383       if( LightApp_Application* anApp =
 384           dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
 385         anApp->browseObjects( anEntryList );
 386
 387       // show Error message box if there were errors
 388       if ( errors.count() > 0 ) {
 389         SUIT_MessageBox::critical( SMESHGUI::desktop(),
 390                                    QObject::tr( "SMESH_ERROR" ),
 391                                    QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
 392       }
 393
 394       // show warning message box, if some imported mesh is empty
 395       if ( isEmpty ) {
 396           SUIT_MessageBox::warning( SMESHGUI::desktop(),
 397                                     QObject::tr( "SMESH_WRN_WARNING" ),
 398                                     QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
 399       }
 400     }
 401   }
 402
 403   //================================================================================
 404   /*!
 405    * \brief Export selected meshes or groups into a file
 406    */
 407   //================================================================================
 408
 409   void ExportMeshToFile( int theCommandID )
 410   {
 411     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 412     SALOME_ListIO selected;
 413     if( aSel )
 414       aSel->selectedObjects( selected );
 415
 416     const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
 417     const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
 418     const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
 419     const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
 420     const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
 421     const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
 422     const bool isGMF = ( theCommandID == 146 || theCommandID == 147 );
 423
 424     // actually, the following condition can't be met (added for insurance)
 425     if( selected.Extent() == 0 ||
 426         ( selected.Extent() > 1 && !isMED && !isSTL ))
 427       return;
 428
 429     // get mesh object from selection and check duplication of their names
 430     bool hasDuplicatedMeshNames = false;
 431     QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
 432     QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
 433     SALOME_ListIteratorOfListIO It( selected );
 434     for( ; It.More(); It.Next() )
 435     {
 436       Handle(SALOME_InteractiveObject) anIObject = It.Value();
 437       SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
 438       if ( aMeshItem->_is_nil() ) {
 439         SUIT_MessageBox::warning( SMESHGUI::desktop(),
 440                                   QObject::tr( "SMESH_WRN_WARNING" ),
 441                                   QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
 442         return;
 443       }
 444
 445       QString aMeshName = anIObject->getName();
 446
 447       // check for name duplications
 448       if ( !hasDuplicatedMeshNames )
 449         for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 450           if( aMeshName == (*aMeshIter).second ) {
 451             hasDuplicatedMeshNames = true;
 452             break;
 453           }
 454         }
 455
 456       aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
 457     }
 458
 459     if( hasDuplicatedMeshNames && isMED ) {
 460       int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 461                                           QObject::tr("SMESH_WRN_WARNING"),
 462                                           QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
 463                                           QObject::tr("SMESH_BUT_YES"),
 464                                           QObject::tr("SMESH_BUT_NO"), 0, 1);
 465       if (aRet != 0)
 466         return;
 467     }
 468
 469     aMeshIter = aMeshList.begin();
 470     SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 471     SMESH::SMESH_Mesh_var            aMesh = aMeshOrGroup->GetMesh();
 472     QString                      aMeshName = (*aMeshIter).second;
 473
 474     if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
 475     {
 476       // check for equal group names within each mesh
 477       for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 478         SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 479         if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
 480           int aRet = SUIT_MessageBox::warning
 481             (SMESHGUI::desktop(),
 482              QObject::tr("SMESH_WRN_WARNING"),
 483              QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
 484              QObject::tr("SMESH_BUT_YES"),
 485              QObject::tr("SMESH_BUT_NO"), 0, 1);
 486           if (aRet != 0)
 487             return;
 488         }
 489       }
 490     }
 491
 492     // Warn the user about presence of not supported elements
 493     QString format;
 494     std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
 495     if ( isDAT )
 496     {
 497       format = "DAT";
 498       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 499       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 500     }
 501     else if ( isUNV )
 502     {
 503       format = "UNV";
 504       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 505       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 506       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 507       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 508       notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
 509       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 510       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 511       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 512     }
 513     else if ( isSTL )
 514     {
 515       format = "STL";
 516       notSupportedElemTypes.push_back( SMESH::Entity_Edge );
 517       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
 518       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 519       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 520     }
 521     else if ( isCGNS )
 522     {
 523       format = "CGNS";
 524       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 525       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
 526     }
 527     else if ( isSAUV )
 528     {
 529       format = "SAUV";
 530       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 531       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
 532       notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
 533       notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
 534       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 535       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 536       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 537     }
 538     else if ( isGMF )
 539     {
 540       format = "GMF";
 541       notSupportedElemTypes.push_back( SMESH::Entity_0D );
 542       notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
 543       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
 544       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
 545       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
 546       notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
 547       notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
 548       notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
 549       notSupportedElemTypes.push_back( SMESH::Entity_Ball );
 550     }
 551     if ( ! notSupportedElemTypes.empty() )
 552     {
 553       SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
 554       for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
 555         if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
 556           presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
 557     }
 558     if ( !presentNotSupported.empty() )
 559     {
 560       QString typeNames;
 561       const char* typeMsg[SMESH::Entity_Last] = {
 562         "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
 563         "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
 564         "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
 565         "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
 566         "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
 567         "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
 568         "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
 569         "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
 570       };
 571       QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
 572       for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
 573         typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
 574         if ( iType != presentNotSupported.size() - 1 )
 575           typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
 576       }
 577       int aRet = SUIT_MessageBox::warning
 578         (SMESHGUI::desktop(),
 579          QObject::tr("SMESH_WRN_WARNING"),
 580          QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
 581          QObject::tr("SMESH_BUT_YES"),
 582          QObject::tr("SMESH_BUT_NO"), 0, 1);
 583       if (aRet != 0)
 584         return;
 585     }
 586
 587     // Get parameters of export operation
 588
 589     QString            aFilename;
 590     SMESH::MED_VERSION aFormat;
 591     // Init the parameters with the default values
 592     bool aIsASCII_STL   = true;
 593     bool toCreateGroups = false;
 594     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 595     if ( resMgr )
 596       toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
 597     bool toOverwrite = true;
 598     bool toFindOutDim = true;
 599
 600     QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
 601     QString anInitialPath = "";
 602     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
 603       anInitialPath = QDir::currentPath();
 604
 605     QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
 606
 607     // Get a file name to write in and additional otions
 608     if ( isUNV || isDAT || isGMF ) // Export w/o options
 609     {
 610       if ( isUNV )
 611         aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
 612       else if ( isDAT )
 613         aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
 614       else if ( isGMF )
 615         aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
 616           ";;" +  QObject::tr( "GMF_BINARY_FILES_FILTER" )  + " (*.meshb)";
 617      if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
 618       aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
 619                                             anInitialPath + QString("/") + aMeshName,
 620                                             aFilter, aTitle, false);
 621     }
 622     else if ( isCGNS )// Export to CGNS
 623     {
 624       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 625       fd->setWindowTitle( aTitle );
 626       fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
 627       if ( !anInitialPath.isEmpty() )
 628         fd->setDirectory( anInitialPath );
 629       fd->selectFile(aMeshName);
 630       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 631       fd->setValidator( fv );
 632
 633       if ( fd->exec() )
 634         aFilename = fd->selectedFile();
 635       toOverwrite = fv->isOverwrite();
 636
 637       delete fd;
 638     }
 639     else if ( isSTL ) // Export to STL
 640     {
 641       QMap<QString, int> aFilterMap;
 642       aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
 643       aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" )   + " (*.stl)", 0 );
 644
 645       QStringList filters;
 646       QMap<QString, int>::const_iterator it = aFilterMap.begin();
 647       for ( ; it != aFilterMap.end(); ++it )
 648         filters.push_back( it.key() );
 649
 650       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
 651       fd->setWindowTitle( aTitle );
 652       fd->setNameFilters( filters );
 653       fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
 654       if ( !anInitialPath.isEmpty() )
 655         fd->setDirectory( anInitialPath );
 656       fd->selectFile(aMeshName);
 657       bool is_ok = false;
 658       while (!is_ok) {
 659         if ( fd->exec() )
 660           aFilename = fd->selectedFile();
 661         aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
 662         is_ok = true;
 663       }
 664       delete fd;
 665     }
 666     else if ( isMED || isSAUV ) // Export to MED or SAUV
 667     {
 668       QMap<QString, SMESH::MED_VERSION> aFilterMap;
 669       //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
 670       if ( isMED ) {
 671         QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
 672         //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
 673         aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
 674       }
 675       else { // isSAUV
 676         aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
 677         aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
 678         aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
 679       }
 680
 681       QStringList filters;
 682       QString aDefaultFilter;
 683       QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
 684       for ( ; it != aFilterMap.end(); ++it ) {
 685         filters.push_back( it.key() );
 686         if (it.value() == SMESH::MED_V2_2)
 687           aDefaultFilter = it.key();
 688       }
 689       QStringList checkBoxes;
 690       checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
 691
 692       SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
 693       QList< QWidget* > wdgList;
 694       if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
 695         wdgList.append( fieldSelWdg );
 696
 697       SalomeApp_CheckFileDlg* fd =
 698         new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
 699       fd->setWindowTitle( aTitle );
 700       fd->setNameFilters( filters );
 701       fd->selectNameFilter( aDefaultFilter );
 702       fd->SetChecked( toCreateGroups, 0 );
 703       fd->SetChecked( toFindOutDim,   1 );
 704       if ( !anInitialPath.isEmpty() )
 705         fd->setDirectory( anInitialPath );
 706       fd->selectFile(aMeshName);
 707
 708       SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
 709       fd->setValidator( fv );
 710
 711       bool is_ok = false;
 712       while (!is_ok) {
 713         if ( fd->exec() )
 714           aFilename = fd->selectedFile();
 715         else {
 716           aFilename = QString::null;
 717           break;
 718         }
 719         aFormat = aFilterMap[fd->selectedNameFilter()];
 720         toOverwrite = fv->isOverwrite();
 721         is_ok = true;
 722         if ( !aFilename.isEmpty() ) {
 723           // med-2.1 does not support poly elements
 724           if ( aFormat==SMESH::MED_V2_1 )
 725             for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 726               SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
 727               SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
 728               if ( nbElems[ SMESH::Entity_Polygon   ] + nbElems[ SMESH::Entity_Quad_Polygon   ] +
 729                    nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
 730               {
 731                 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 732                                                     QObject::tr("SMESH_WRN_WARNING"),
 733                                                     QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
 734                                                     QObject::tr("SMESH_BUT_YES"),
 735                                                     QObject::tr("SMESH_BUT_NO"), 0, 1);
 736                 if (aRet != 0) {
 737                   is_ok = false;
 738                   break;
 739                 }
 740               }
 741             }
 742           if( !toOverwrite ) {
 743             // can't append to an existing using other format
 744             SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
 745             bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
 746             if( !isVersionOk || aVersion != aFormat ) {
 747               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 748                                                   QObject::tr("SMESH_WRN_WARNING"),
 749                                                   QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
 750                                                   QObject::tr("SMESH_BUT_YES"),
 751                                                   QObject::tr("SMESH_BUT_NO"), 0, 1);
 752               if (aRet == 0)
 753                 toOverwrite = true;
 754               else
 755                 is_ok = false;
 756             }
 757
 758             QStringList aMeshNamesCollisionList;
 759             SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
 760             for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
 761               QString anExistingMeshName( aMeshNames[ i ] );
 762               for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
 763                 QString anExportMeshName = (*aMeshIter).second;
 764                 if( anExportMeshName == anExistingMeshName ) {
 765                   aMeshNamesCollisionList.append( anExportMeshName );
 766                   break;
 767                 }
 768               }
 769             }
 770             if( !aMeshNamesCollisionList.isEmpty() ) {
 771               QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
 772               int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
 773                                                   QObject::tr("SMESH_WRN_WARNING"),
 774                                                   QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
 775                                                   QObject::tr("SMESH_BUT_YES"),
 776                                                   QObject::tr("SMESH_BUT_NO"),
 777                                                   QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
 778               if (aRet == 0)
 779                 toOverwrite = true;
 780               else if (aRet == 2)
 781                 is_ok = false;
 782             }
 783           }
 784         }
 785       }
 786       toCreateGroups = fd->IsChecked(0);
 787       toFindOutDim   = fd->IsChecked(1);
 788       fieldSelWdg->GetSelectedFeilds();
 789       if ( !fieldSelWdg->parent() )
 790         delete fieldSelWdg;
 791       delete fd;
 792     }
 793     else
 794     {
 795       return;
 796     }
 797
 798     // Perform export
 799
 800     if ( !aFilename.isEmpty() ) {
 801       // Check whether the file already exists and delete it if yes
 802       QFile aFile( aFilename );
 803       if ( aFile.exists() && toOverwrite )
 804         aFile.remove();
 805       SUIT_OverrideCursor wc;
 806
 807       try {
 808         // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
 809 //         bool Renumber = false;
 810 //         // PAL 14172  : Check of we have to renumber or not from the preferences before export
 811 //         if (resMgr)
 812 //           Renumber= resMgr->booleanValue("renumbering");
 813 //         if (Renumber){
 814 //           SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
 815 //           aMeshEditor->RenumberNodes();
 816 //           aMeshEditor->RenumberElements();
 817 //           if ( SMESHGUI::automaticUpdate() )
 818 //             SMESH::UpdateView();
 819 //         }
 820         if ( isMED )
 821         {
 822           aMeshIter = aMeshList.begin();
 823           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 824           {
 825             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 826             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 827             const GEOM::ListOfFields&       fields = aFieldList[ aMeshIndex ].first.in();
 828             const QString&            geoAssFields = aFieldList[ aMeshIndex ].second;
 829             const bool                   hasFields = ( fields.length() || !geoAssFields.isEmpty() );
 830             if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
 831               aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
 832                                        aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
 833             else
 834               aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
 835                                           aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
 836                                           fields, geoAssFields.toLatin1().data() );
 837           }
 838         }
 839         else if ( isSAUV )
 840         {
 841           for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
 842           {
 843             SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
 844             if( !aMeshItem->_is_nil() )
 845               aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
 846           }
 847         }
 848         else if ( isDAT )
 849         {
 850           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 851             aMesh->ExportDAT( aFilename.toUtf8().data() );
 852           else
 853             aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
 854         }
 855         else if ( isUNV )
 856         {
 857           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 858             aMesh->ExportUNV( aFilename.toUtf8().data() );
 859           else
 860             aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
 861         }
 862         else if ( isSTL )
 863         {
 864           if ( aMeshOrGroup->_is_equivalent( aMesh ))
 865             aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
 866           else
 867             aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
 868         }
 869         else if ( isCGNS )
 870         {
 871           aMeshIter = aMeshList.begin();
 872           for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
 873           {
 874             SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
 875             SMESH::SMESH_Mesh_var        aMeshItem = aMeshOrGroup->GetMesh();
 876             aMeshItem->ExportCGNS( aMeshOrGroup,
 877                                    aFilename.toUtf8().data(),
 878                                    toOverwrite && aMeshIndex == 0 );
 879           }
 880         }
 881         else if ( isGMF )
 882         {
 883           toCreateGroups = true;
 884           aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
 885         }
 886       }
 887       catch (const SALOME::SALOME_Exception& S_ex){
 888         wc.suspend();
 889         SUIT_MessageBox::warning(SMESHGUI::desktop(),
 890                                  QObject::tr("SMESH_WRN_WARNING"),
 891                                  QObject::tr("SMESH_EXPORT_FAILED"));
 892         wc.resume();
 893       }
 894     }
 895   }
 896
 897   inline void InverseEntityMode(unsigned int& theOutputMode,
 898                                 unsigned int theMode)
 899   {
 900     bool anIsNotPresent = ~theOutputMode & theMode;
 901     if(anIsNotPresent)
 902       theOutputMode |= theMode;
 903     else
 904       theOutputMode &= ~theMode;
 905   }
 906
 907   void SetDisplayEntity(int theCommandID){
 908     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
 909     SALOME_ListIO selected;
 910     if( aSel )
 911       aSel->selectedObjects( selected );
 912
 913     if(selected.Extent() >= 1){
 914       SALOME_ListIteratorOfListIO It( selected );
 915       for( ; It.More(); It.Next()){
 916         Handle(SALOME_InteractiveObject) IObject = It.Value();
 917         if(IObject->hasEntry()){
 918           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
 919             unsigned int aMode = anActor->GetEntityMode();
 920             switch(theCommandID){
 921             case 222:
 922               InverseEntityMode(aMode,SMESH_Actor::eBallElem);
 923               break;
 924             case 216:
 925               InverseEntityMode(aMode,SMESH_Actor::e0DElements);
 926               break;
 927             case 217:
 928               InverseEntityMode(aMode,SMESH_Actor::eEdges);
 929               break;
 930             case 218:
 931               InverseEntityMode(aMode,SMESH_Actor::eFaces);
 932               break;
 933             case 219:
 934               InverseEntityMode(aMode,SMESH_Actor::eVolumes);
 935               break;
 936             case 220:
 937               aMode = SMESH_Actor::eAllEntity;
 938               break;
 939             }
 940             if(aMode)
 941               anActor->SetEntityMode(aMode);
 942           }
 943         }
 944       }
 945     }
 946   }
 947
 948   void AutoColor()
 949   {
 950     SALOME_ListIO selected;
 951     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 952     if( !app )
 953       return;
 954
 955     LightApp_SelectionMgr* aSel = app->selectionMgr();
 956     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
 957     if( !aSel || !appStudy )
 958       return;
 959
 960     aSel->selectedObjects( selected );
 961     if( selected.IsEmpty() )
 962       return;
 963
 964     Handle(SALOME_InteractiveObject) anIObject = selected.First();
 965
 966     _PTR(Study) aStudy = appStudy->studyDS();
 967     _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
 968     SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
 969     if( aMainObject->_is_nil() )
 970       return;
 971
 972     SUIT_OverrideCursor wc;
 973
 974     aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
 975
 976     QList<SALOMEDS::Color> aReservedColors;
 977
 978     SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
 979     for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
 980     {
 981       SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
 982       //SALOMEDS::Color aColor = aGroupObject->GetColor();
 983
 984 #ifdef SIMPLE_AUTOCOLOR   // simplified algorithm for auto-colors
 985       SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
 986 #else                     // old algorithm  for auto-colors
 987       SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
 988       aReservedColors.append( aColor );
 989 #endif                    // SIMPLE_AUTOCOLOR
 990       aGroupObject->SetColor( aColor );
 991
 992       _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
 993       if (aGroupSObject) {
 994         QColor c;
 995         int delta;
 996         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
 997           switch ( aGroupObject->GetType ()) {
 998           case SMESH::NODE:
 999             anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1000           case SMESH::EDGE:
1001             anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1002           case SMESH::ELEM0D:
1003             anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1004           case SMESH::BALL:
1005             anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1006           case SMESH::VOLUME:
1007             SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1008             anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1009           case SMESH::FACE:
1010           default:
1011             SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1012             anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1013           }
1014         }
1015       }
1016     }
1017
1018     SMESH::RepaintCurrentView();
1019   }
1020
1021   void OverallMeshQuality() {
1022     SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1023     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1024     SALOME_ListIO selected;
1025     if( aSel )
1026       aSel->selectedObjects( selected );
1027
1028     if ( selected.IsEmpty() ) return;
1029     SALOME_ListIteratorOfListIO It( selected );
1030     for ( ; It.More(); It.Next() ) {
1031       SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1032       ctrlDlg->showInfo( It.Value() );
1033       ctrlDlg->show();
1034     }
1035   }
1036
1037   QString functorToString( SMESH::Controls::FunctorPtr f )
1038   {
1039     QString type = QObject::tr( "UNKNOWN_CONTROL" );
1040     if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1041       type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1042     else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1043       type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1044     else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1045       type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1046     else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1047       type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1048     else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1049       type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1050     else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1051       type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1052     else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1053       type = QObject::tr( "WARP_ELEMENTS" );
1054     else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1055       type = QObject::tr( "TAPER_ELEMENTS" );
1056     else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1057       type = QObject::tr( "SKEW_ELEMENTS" );
1058     else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1059       type = QObject::tr( "AREA_ELEMENTS" );
1060     else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1061       type = QObject::tr( "LENGTH_EDGES" );
1062     else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1063       type = QObject::tr( "LENGTH2D_EDGES" );
1064     else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1065       type = QObject::tr( "MULTI_BORDERS" );
1066     else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1067       type = QObject::tr( "MULTI2D_BORDERS" );
1068     else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1069       type = QObject::tr( "FREE_NODES" );
1070     else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1071       type = QObject::tr( "FREE_EDGES" );
1072     else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1073       type = QObject::tr( "FREE_BORDERS" );
1074     else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1075       type = QObject::tr( "FREE_FACES" );
1076     else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1077       type = QObject::tr( "BARE_BORDER_VOLUME" );
1078     else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1079       type = QObject::tr( "BARE_BORDER_FACE" );
1080     else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1081       type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1082     else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1083       type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1084     else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1085       type = QObject::tr( "EQUAL_NODE" );
1086     else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1087       type = QObject::tr( "EQUAL_EDGE" );
1088     else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1089       type = QObject::tr( "EQUAL_FACE" );
1090     else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1091       type = QObject::tr( "EQUAL_VOLUME" );
1092     return type;
1093   }
1094
1095   void SaveDistribution()
1096   {
1097     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1098     SALOME_ListIO selected;
1099     if ( aSel )
1100       aSel->selectedObjects( selected );
1101
1102     if ( selected.Extent() == 1 ) {
1103       Handle(SALOME_InteractiveObject) anIO = selected.First();
1104       if ( anIO->hasEntry() ) {
1105         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1106         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1107           SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1108           SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1109           if ( aScalarBarActor && aFunctor ) {
1110             SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1111             if ( aNumFun ) {
1112               std::vector<int> elements;
1113               SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1114               if ( mesh->_is_nil() ) {
1115                 SMESH::SMESH_IDSource_var idSource =
1116                   SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1117                 if ( !idSource->_is_nil() )
1118                 {
1119                   SMESH::long_array_var ids = idSource->GetIDs();
1120                   elements.resize( ids->length() );
1121                   for ( unsigned i = 0; i < elements.size(); ++i )
1122                     elements[i] = ids[i];
1123                 }
1124               }
1125               int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1126               vtkLookupTable* lookupTable =
1127                 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1128               double * minmax = lookupTable->GetRange();
1129               bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1130               std::vector<int>    nbEvents;
1131               std::vector<double> funValues;
1132               aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1133               QString anInitialPath = "";
1134               if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1135                 anInitialPath = QDir::currentPath();
1136               QString aMeshName = anIO->getName();
1137               QStringList filter;
1138               filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1139               filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1140               QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1141                 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1142               aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1143                                                      aFilename,
1144                                                      filter,
1145                                                      QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1146                                                      false );
1147               if ( !aFilename.isEmpty() ) {
1148                 QFile f( aFilename );
1149                 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1150                   QTextStream out( &f );
1151                   out << "# Mesh: " << aMeshName << endl;
1152                   out << "# Control: " << functorToString( aFunctor ) << endl;
1153                   out << "#" << endl;
1154                   out.setFieldWidth( 10 );
1155                   for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1156                     out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1157                   f.close();
1158                 }
1159               }
1160             }
1161           }
1162         }
1163       }
1164     }
1165   }
1166
1167   void ShowDistribution() {
1168     LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1169     SALOME_ListIO selected;
1170     if ( aSel )
1171       aSel->selectedObjects( selected );
1172
1173     if ( selected.Extent() == 1 ) {
1174       Handle(SALOME_InteractiveObject) anIO = selected.First();
1175       if ( anIO->hasEntry() ) {
1176         SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1177         if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1178           SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1179           aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1180         }
1181       }
1182     }
1183   }
1184
1185 #ifndef DISABLE_PLOT2DVIEWER
1186  void PlotDistribution() {
1187    SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1188    if( !app )
1189      return;
1190
1191    LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1192    SALOME_ListIO selected;
1193    if ( aSel )
1194      aSel->selectedObjects( selected );
1195
1196    if ( selected.Extent() == 1 ) {
1197      Handle(SALOME_InteractiveObject) anIO = selected.First();
1198      if ( anIO->hasEntry() ) {
1199        //Find Actor by entry before getting Plot2d viewer,
1200        //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1201        SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1202
1203        SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1204
1205        if( !aViewManager )
1206          return;
1207
1208        SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1209        if ( !aView )
1210          return;
1211
1212        Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1213        if ( !aPlot )
1214          return;
1215
1216        if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1217          SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1218          QString functorName = functorToString( anActor->GetFunctor());
1219          QString aHistogramName("%1 : %2");
1220          aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1221          aHistogram->setName(aHistogramName);
1222          aHistogram->setHorTitle(functorName);
1223          aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1224          aPlot->displayObject(aHistogram, true);
1225        }
1226      }
1227    }
1228  }
1229 #endif //DISABLE_PLOT2DVIEWER
1230
1231   void DisableAutoColor(){
1232     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1233     SALOME_ListIO selected;
1234     if( aSel )
1235       aSel->selectedObjects( selected );
1236
1237     if(selected.Extent()){
1238       Handle(SALOME_InteractiveObject) anIObject = selected.First();
1239       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1240       if ( !aMesh->_is_nil() ) {
1241         aMesh->SetAutoColor( false );
1242       }
1243     }
1244   }
1245
1246   void sortChildren(){
1247     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1248     SALOME_ListIO selected;
1249     if( aSel ) {
1250       aSel->selectedObjects( selected );
1251
1252       if(selected.Extent()){
1253         Handle(SALOME_InteractiveObject) anIObject = selected.First();
1254         _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1255         _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1256         if (aSObj) {
1257           if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1258             SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1259           }
1260         }
1261       }
1262     }
1263   }
1264
1265   void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1266   {
1267     SALOME_ListIO selected;
1268     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1269     if( !app )
1270       return;
1271
1272     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1273     SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1274     if( !aSel || !appStudy )
1275       return;
1276
1277     if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1278       if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1279         aModule->EmitSignalDeactivateDialog();
1280         if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1281           (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1282       }
1283       return;
1284     }
1285
1286     _PTR(Study) aStudy = appStudy->studyDS();
1287
1288     aSel->selectedObjects( selected );
1289
1290     if(selected.Extent() >= 1){
1291       switch(theCommandID){
1292       case 1133:{
1293         SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1294         (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1295         return;
1296       }
1297       case 1132: {
1298         double color[3];
1299         QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1300         QColor orientationColor, outlineColor, volumeColor;
1301         int deltaF = 0, deltaV = 0;
1302         int elem0dSize   = 1;
1303         int ballSize     = 1;
1304         double ballScale = 1.0;
1305         int edgeWidth    = 1;
1306         int outlineWidth = 1;
1307         double shrinkCoef = 0.0;
1308         double orientationScale = 0.0;
1309         bool orientation3d = false;
1310         VTK::MarkerType markerType = VTK::MT_NONE;
1311         VTK::MarkerScale markerScale = VTK::MS_NONE;
1312         int markerId = 0;
1313         bool hasNodes = false;
1314         int presentEntities = 0;
1315         bool firstTime  = true;
1316
1317         SALOME_ListIteratorOfListIO It( selected );
1318         for ( ; It.More(); It.Next() ) {
1319           Handle(SALOME_InteractiveObject) IObject = It.Value();
1320           if ( !IObject->hasEntry() ) continue;
1321           SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1322           if ( !anActor || !anActor->GetObject() ) continue;
1323
1324           if ( firstTime ) {
1325             // nodes: color, marker
1326             anActor->GetNodeColor( color[0], color[1], color[2] );
1327             nodeColor.setRgbF( color[0], color[1], color[2] );
1328             markerType  = anActor->GetMarkerType();
1329             markerScale = anActor->GetMarkerScale();
1330             markerId    = anActor->GetMarkerTexture();
1331             // edges: color, width
1332             anActor->GetEdgeColor( color[0], color[1], color[2] );
1333             edgeColor.setRgbF( color[0], color[1], color[2] );
1334             edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1335             // faces: front color, back color (delta)
1336             anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1337             faceColor.setRgbF( color[0], color[1], color[2] );
1338             // faces: front color, back color (delta)
1339             anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1340             volumeColor.setRgbF( color[0], color[1], color[2] );
1341             // 0d elements: color, size
1342             anActor->Get0DColor( color[0], color[1], color[2] );
1343             elem0dColor.setRgbF( color[0], color[1], color[2] );
1344             elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1345             // balls: color, size
1346             anActor->GetBallColor( color[0], color[1], color[2] );
1347             ballColor.setRgbF( color[0], color[1], color[2] );
1348             ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1349             ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1350             // outlines: color
1351             anActor->GetOutlineColor( color[0], color[1], color[2] );
1352             outlineColor.setRgbF( color[0], color[1], color[2] );
1353             outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1354             // orientation vectors: color, scale, 3d flag
1355             anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1356             orientationColor.setRgbF( color[0], color[1], color[2] );
1357             orientationScale = anActor->GetFacesOrientationScale();
1358             orientation3d = anActor->GetFacesOrientation3DVectors();
1359             // shrink factor
1360             shrinkCoef = anActor->GetShrinkFactor();
1361           }
1362
1363           firstTime = false; // we only take properties from first object (for performance reasons)
1364
1365           if ( !hasNodes )
1366             hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1367           if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1368             presentEntities = presentEntities | SMESH_Actor::eEdges;
1369           if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1370             presentEntities = presentEntities | SMESH_Actor::eFaces;
1371           if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1372             presentEntities = presentEntities | SMESH_Actor::eVolumes;
1373           if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1374             presentEntities = presentEntities | SMESH_Actor::e0DElements;
1375           if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1376             presentEntities = presentEntities | SMESH_Actor::eBallElem;
1377
1378           // as we know that all types of elements are present, we can exit the loop
1379           if ( presentEntities == SMESH_Actor::eAllEntity )
1380             break;
1381         }
1382
1383         SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1384         // nodes: color, marker
1385         dlg.setNodeColor( nodeColor );
1386         if( markerType != VTK::MT_USER )
1387           dlg.setNodeMarker( markerType, markerScale );
1388         else
1389           dlg.setNodeCustomMarker( markerId );
1390         // edges: color, line width
1391         dlg.setEdgeColor( edgeColor );
1392         dlg.setEdgeWidth( edgeWidth );
1393         // faces: front color, back color
1394         dlg.setFaceColor( faceColor, deltaF );
1395         // volumes: normal color, reversed color
1396         dlg.setVolumeColor( volumeColor, deltaV );
1397         // outlines: color, line width
1398         dlg.setOutlineColor( outlineColor );
1399         dlg.setOutlineWidth( outlineWidth );
1400         // 0d elements: color, size
1401         dlg.setElem0dColor( elem0dColor );
1402         dlg.setElem0dSize( elem0dSize );
1403         // balls: color, size
1404         dlg.setBallColor( ballColor );
1405         dlg.setBallSize( ballSize );
1406         dlg.setBallScale( ballScale );
1407         // orientation: color, scale, 3d flag
1408         dlg.setOrientationColor( orientationColor );
1409         dlg.setOrientationSize( int( orientationScale * 100. ) );
1410         dlg.setOrientation3d( orientation3d );
1411         // shrink: scale factor
1412         dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1413         // hide unused controls
1414         dlg.showControls( presentEntities, hasNodes );
1415
1416         if ( dlg.exec() ) {
1417           nodeColor        = dlg.nodeColor();
1418           markerType       = dlg.nodeMarkerType();
1419           markerScale      = dlg.nodeMarkerScale();
1420           markerId         = dlg.nodeMarkerId();
1421           edgeColor        = dlg.edgeColor();
1422           edgeWidth        = dlg.edgeWidth();
1423           faceColor        = dlg.faceColor();
1424           deltaF           = dlg.faceColorDelta();
1425           volumeColor      = dlg.volumeColor();
1426           deltaV           = dlg.volumeColorDelta();
1427           outlineColor     = dlg.outlineColor();
1428           outlineWidth     = dlg.outlineWidth();
1429           elem0dColor      = dlg.elem0dColor();
1430           elem0dSize       = dlg.elem0dSize();
1431           ballColor        = dlg.ballColor();
1432           ballSize         = dlg.ballSize();
1433           ballScale        = dlg.ballScale();
1434           orientationColor = dlg.orientationColor();
1435           orientationScale = dlg.orientationSize() / 100.;
1436           orientation3d    = dlg.orientation3d();
1437           shrinkCoef       = dlg.shrinkCoef() / 100.;
1438
1439           // store point markers map that might be changed by the user
1440           theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1441
1442           // set properties from dialog box to the presentations
1443           SALOME_ListIteratorOfListIO It( selected );
1444           for ( ; It.More(); It.Next() ) {
1445             Handle(SALOME_InteractiveObject) IObject = It.Value();
1446             if ( !IObject->hasEntry() ) continue;
1447             SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1448             if ( !anActor ) continue;
1449
1450             // nodes: color, marker
1451             anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1452             if ( markerType != VTK::MT_USER ) {
1453               anActor->SetMarkerStd( markerType, markerScale );
1454             }
1455             else {
1456               const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1457               VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1458               if ( iter != markerMap.end() )
1459                 anActor->SetMarkerTexture( markerId, iter->second.second );
1460             }
1461             // volumes: normal color, reversed color (delta)
1462             anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1463             // faces: front color, back color (delta)
1464             anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1465             // edges: color, width
1466             anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1467             anActor->SetLineWidth( edgeWidth );
1468             // outlines: color
1469             anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1470             anActor->SetOutlineWidth( outlineWidth );
1471             // 0D elements: color, size
1472             anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1473             anActor->Set0DSize( elem0dSize );
1474             // balls: color, size
1475             anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1476             anActor->SetBallSize( ballSize );
1477             anActor->SetBallScale( ballScale );
1478             // orientation: color, scale, 3d flag
1479             anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1480             anActor->SetFacesOrientationScale( orientationScale );
1481             anActor->SetFacesOrientation3DVectors( orientation3d );
1482             // shrink factor
1483             anActor->SetShrinkFactor( shrinkCoef );
1484
1485             // for groups, set also proper color
1486             SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1487             if ( !aGroupObject->_is_nil() ) {
1488               SMESH::ElementType anElementType = aGroupObject->GetType();
1489               QColor aColor;
1490               switch( anElementType ) {
1491               case SMESH::NODE:
1492                 aColor = nodeColor; break;
1493               case SMESH::EDGE:
1494                 aColor = edgeColor; break;
1495               case SMESH::FACE:
1496                 aColor = faceColor; break;
1497               case SMESH::VOLUME:
1498                 aColor = volumeColor; break;
1499               case SMESH::ELEM0D:
1500                 aColor = elem0dColor; break;
1501               case SMESH::BALL:
1502                 aColor = ballColor; break;
1503               default: break;
1504               }
1505
1506               if ( aColor.isValid() ) {
1507                 SALOMEDS::Color aGroupColor;
1508                 aGroupColor.R = aColor.redF();
1509                 aGroupColor.G = aColor.greenF();
1510                 aGroupColor.B = aColor.blueF();
1511                 aGroupObject->SetColor( aGroupColor );
1512               }
1513             } // if ( !aGroupObject->_is_nil() )
1514           } // for ( ; It.More(); It.Next() )
1515           SMESH::RepaintCurrentView();
1516         } // if ( dlg.exec() )
1517         return;
1518       } // case 1132:
1519       } // switch(theCommandID)
1520       SALOME_ListIteratorOfListIO It( selected );
1521       for( ; It.More(); It.Next()){
1522         Handle(SALOME_InteractiveObject) IObject = It.Value();
1523         if(IObject->hasEntry()){
1524           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1525             switch(theCommandID){
1526             case 211:
1527               anActor->SetRepresentation(SMESH_Actor::eEdge);
1528               break;
1529             case 212:
1530               anActor->SetRepresentation(SMESH_Actor::eSurface);
1531               break;
1532             case 213:
1533               if(anActor->IsShrunk())
1534                 anActor->UnShrink();
1535               else
1536                 anActor->SetShrink();
1537               break;
1538             case 215:
1539               anActor->SetRepresentation(SMESH_Actor::ePoint);
1540               break;
1541             case 231:
1542               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1543                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1544               break;
1545             case 232:
1546               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1547                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1548               break;
1549             }
1550           }
1551         }
1552       }
1553       SMESH::RepaintCurrentView();
1554     }
1555   }
1556
1557   void Control( int theCommandID )
1558   {
1559     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1560     SALOME_ListIO selected;
1561     if( aSel )
1562       aSel->selectedObjects( selected );
1563
1564     if( !selected.IsEmpty() ){
1565       Handle(SALOME_InteractiveObject) anIO = selected.First();
1566       if(!anIO.IsNull()){
1567         SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1568         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1569           switch ( theCommandID ){
1570           case 6001:
1571             aControl = SMESH_Actor::eLength;
1572             break;
1573           case 6018:
1574             aControl = SMESH_Actor::eLength2D;
1575             break;
1576           case 6002:
1577             aControl = SMESH_Actor::eFreeEdges;
1578             break;
1579           case 6003:
1580             aControl = SMESH_Actor::eFreeBorders;
1581             break;
1582           case 6004:
1583             aControl = SMESH_Actor::eMultiConnection;
1584             break;
1585           case 6005:
1586             aControl = SMESH_Actor::eFreeNodes;
1587             break;
1588           case 6019:
1589             aControl = SMESH_Actor::eMultiConnection2D;
1590             break;
1591           case 6011:
1592             aControl = SMESH_Actor::eArea;
1593             break;
1594           case 6012:
1595             aControl = SMESH_Actor::eTaper;
1596             break;
1597           case 6013:
1598             aControl = SMESH_Actor::eAspectRatio;
1599             break;
1600           case 6017:
1601             aControl = SMESH_Actor::eAspectRatio3D;
1602             break;
1603           case 6014:
1604             aControl = SMESH_Actor::eMinimumAngle;
1605             break;
1606           case 6015:
1607             aControl = SMESH_Actor::eWarping;
1608             break;
1609           case 6016:
1610             aControl = SMESH_Actor::eSkew;
1611             break;
1612           case 6009:
1613             aControl = SMESH_Actor::eVolume3D;
1614             break;
1615           case 6021:
1616             aControl = SMESH_Actor::eFreeFaces;
1617             break;
1618           case 6022:
1619             aControl = SMESH_Actor::eMaxElementLength2D;
1620             break;
1621           case 6023:
1622             aControl = SMESH_Actor::eMaxElementLength3D;
1623             break;
1624           case 6024:
1625             aControl = SMESH_Actor::eBareBorderVolume;
1626             break;
1627           case 6025:
1628             aControl = SMESH_Actor::eBareBorderFace;
1629             break;
1630           case 6026:
1631             aControl = SMESH_Actor::eOverConstrainedVolume;
1632             break;
1633           case 6027:
1634             aControl = SMESH_Actor::eOverConstrainedFace;
1635             break;
1636           case 6028:
1637             aControl = SMESH_Actor::eCoincidentNodes;
1638             break;
1639           case 6029:
1640             aControl = SMESH_Actor::eCoincidentElems1D;
1641             break;
1642           case 6030:
1643             aControl = SMESH_Actor:: eCoincidentElems2D;
1644             break;
1645           case 6031:
1646             aControl = SMESH_Actor::eCoincidentElems3D;
1647             break;
1648           }
1649
1650           anActor->SetControlMode(aControl);
1651           anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1652           SMESH::RepaintCurrentView();
1653 #ifndef DISABLE_PLOT2DVIEWER
1654           if(anActor->GetPlot2Histogram()) {
1655             SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1656             QString functorName = functorToString( anActor->GetFunctor());
1657             QString aHistogramName("%1 : %2");
1658             aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1659             aHistogram->setName(aHistogramName);
1660             aHistogram->setHorTitle(functorName);
1661             SMESH::ProcessIn2DViewers(anActor);
1662           }
1663 #endif
1664         }
1665       }
1666     }
1667   }
1668
1669
1670   bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1671                    SMESH::MeshObjectType                           theType,
1672                    const QString                            theInTypeName,
1673                    QString &                                theOutTypeName)
1674   {
1675     SMESH_TypeFilter aTypeFilter( theType );
1676     QString entry;
1677     if( !theIO.IsNull() )
1678     {
1679       entry = theIO->getEntry();
1680       LightApp_DataOwner owner( entry );
1681       if ( aTypeFilter.isOk( &owner )) {
1682         theOutTypeName = theInTypeName;
1683         return true;
1684       }
1685     }
1686     return false;
1687   }
1688
1689
1690   QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1691   {
1692     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1693     _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1694     if (aSObj) {
1695       _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1696       CORBA::String_var anID = aSComp->GetID().c_str();
1697       if (!strcmp(anID.in(),theIO->getEntry()))
1698         return "Component";
1699     }
1700
1701     QString aTypeName;
1702     if (
1703         CheckOIType ( theIO, SMESH::HYPOTHESIS,    "Hypothesis", aTypeName ) ||
1704         CheckOIType ( theIO, SMESH::ALGORITHM,     "Algorithm",  aTypeName ) ||
1705         CheckOIType ( theIO, SMESH::MESH,          "Mesh",       aTypeName ) ||
1706         CheckOIType ( theIO, SMESH::SUBMESH,       "SubMesh",    aTypeName ) ||
1707         CheckOIType ( theIO, SMESH::GROUP,         "Group",      aTypeName )
1708         )
1709       return aTypeName;
1710
1711     return "NoType";
1712   }
1713
1714
1715   QString CheckHomogeneousSelection()
1716   {
1717     //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1718     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1719     SALOME_ListIO selected;
1720     if( aSel )
1721       aSel->selectedObjects( selected );
1722
1723     QString RefType = CheckTypeObject(selected.First());
1724     SALOME_ListIteratorOfListIO It(selected);
1725     for ( ; It.More(); It.Next())
1726     {
1727       Handle(SALOME_InteractiveObject) IObject = It.Value();
1728       QString Type = CheckTypeObject(IObject);
1729       if (Type.compare(RefType) != 0)
1730         return "Heterogeneous Selection";
1731     }
1732
1733     return RefType;
1734   }
1735
1736 } //namespace
1737
1738 void SMESHGUI::OnEditDelete()
1739 {
1740   // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1741   LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1742   SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1743
1744   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1745   _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1746   _PTR(GenericAttribute) anAttr;
1747   _PTR(AttributeIOR) anIOR;
1748
1749   int objectCount = 0;
1750   QString aNameList;
1751   QString aParentComponent = QString::null;
1752   Handle(SALOME_InteractiveObject) anIO;
1753   for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1754   {
1755     anIO = anIt.Value();
1756     QString cur = anIO->getComponentDataType();
1757     _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1758     if (aSO) {
1759       // check if object is reference
1760       _PTR(SObject) aRefSObj;
1761       aNameList.append("\n    - ");
1762       if ( aSO->ReferencedObject( aRefSObj ) ) {
1763         QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1764         aNameList.append( aRefName );
1765         cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1766       }
1767       else
1768         aNameList.append(anIO->getName());
1769       objectCount++;
1770     }
1771
1772     if( aParentComponent.isNull() )
1773       aParentComponent = cur;
1774     else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1775       aParentComponent = "";
1776   }
1777
1778   if ( objectCount == 0 )
1779     return; // No Valid Objects Selected
1780
1781   if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
1782     SUIT_MessageBox::warning( SMESHGUI::desktop(),
1783                               QObject::tr("ERR_ERROR"),
1784                               QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1785     return;
1786   }
1787   // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1788   if (SUIT_MessageBox::warning
1789       (SMESHGUI::desktop(),
1790        QObject::tr("SMESH_WRN_WARNING"),
1791        QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1792        SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1793        SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1794     return;
1795
1796   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1797
1798   // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1799   // then treat them all starting from the deepest objects (at list back)
1800   std::list< _PTR(SObject) > listSO;
1801   SALOME_ListIteratorOfListIO It(selected);
1802   for( ; It.More(); It.Next()) // loop on selected IO's
1803   {
1804     Handle(SALOME_InteractiveObject) IObject = It.Value();
1805     if(IObject->hasEntry()) {
1806       _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1807
1808       // disable removal of "SMESH" component object
1809       if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1810         anIOR = anAttr;
1811         if ( engineIOR() == anIOR->Value().c_str() )
1812           continue;
1813       }
1814       //Check the referenced object
1815       _PTR(SObject) aRefSObject;
1816       if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1817         aSO = aRefSObject; // Delete main Object instead of reference
1818
1819       listSO.push_back( aSO );
1820       std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1821       for ( ; itSO != listSO.end(); ++itSO ) {
1822         _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1823         for (it->InitEx(false); it->More(); it->Next())
1824           listSO.push_back( it->Value() );
1825       }
1826     }
1827   }
1828   // Check if none of objects to delete is referred from outside
1829   std::list< _PTR(SObject) >::reverse_iterator ritSO;
1830   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1831   {
1832     _PTR(SObject) SO = *ritSO;
1833     if ( !SO ) continue;
1834     std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO  );
1835     for (size_t i = 0; i < aReferences.size(); i++) {
1836       _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1837       std::string type = aComponent->ComponentDataType();
1838       if ( type != "SMESH" )
1839       {
1840         SUIT_MessageBox::warning( anApp->desktop(),
1841                                   QObject::tr("WRN_WARNING"),
1842                                   QObject::tr("DEP_OBJECT") );
1843         return; // outside SMESH, there is an object depending on a SMESH object
1844       }
1845     }
1846   }
1847
1848   // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1849   for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1850   {
1851     Handle(SALOME_InteractiveObject) IObject = It.Value();
1852     SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1853     if ( !mesh->_is_nil() )
1854       mesh->Clear();
1855   }
1856
1857   // Treat SO's in the list starting from the back
1858   aStudyBuilder->NewCommand();  // There is a transaction
1859   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1860   {
1861     _PTR(SObject) SO = *ritSO;
1862     if ( !SO ) continue;
1863     std::string anEntry = SO->GetID();
1864
1865     /** Erase graphical object and remove all its data **/
1866     if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1867       SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1868     }
1869     /** Remove an object from data structures **/
1870     SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1871     SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1872     if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
1873       SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1874       aMesh->RemoveGroup( aGroup );
1875     }
1876     else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
1877       SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1878       aMesh->RemoveSubMesh( aSubMesh );
1879
1880       _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1881       if (aMeshSO)
1882         SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1883     }
1884     else {
1885       Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1886         ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1887       QString objType = CheckTypeObject(IObject);
1888       if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1889         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1890         aStudyBuilder->RemoveObjectWithChildren( SO );
1891       }
1892       else {// default action: remove SObject from the study
1893         // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1894         //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1895         //op->start();
1896         aStudyBuilder->RemoveObjectWithChildren( SO );
1897         //op->finish();
1898       }
1899     }
1900   } /* listSO back loop */
1901
1902   aStudyBuilder->CommitCommand();
1903
1904   /* Clear any previous selection */
1905   SALOME_ListIO l1;
1906   aSel->setSelectedObjects( l1 );
1907
1908   SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1909 }
1910
1911 extern "C" {
1912   SMESHGUI_EXPORT CAM_Module* createModule()
1913   {
1914     return new SMESHGUI();
1915   }
1916
1917   SMESHGUI_EXPORT  char* getModuleVersion() {
1918     return (char*)SMESH_VERSION_STR;
1919   }
1920 }
1921
1922 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1923
1924 //=============================================================================
1925 /*!
1926  *
1927  */
1928 //=============================================================================
1929 SMESHGUI::SMESHGUI() :
1930 SalomeApp_Module( "SMESH" )
1931 {
1932   if ( CORBA::is_nil( myComponentSMESH ) )
1933   {
1934     CORBA::Boolean anIsEmbeddedMode;
1935     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1936     MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1937
1938     //  0019923: EDF 765 SMESH : default values of hypothesis
1939     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1940     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1941     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1942     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1943     myComponentSMESH->SetDefaultNbSegments( nbSeg );
1944
1945     const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1946     for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1947       if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1948       {
1949         QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1950         myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1951       }
1952   }
1953
1954   myActiveDialogBox = 0;
1955   myFilterLibraryDlg = 0;
1956   myState = -1;
1957   myDisplayer = 0;
1958
1959   myEventCallbackCommand = vtkCallbackCommand::New();
1960   myEventCallbackCommand->Delete();
1961   myEventCallbackCommand->SetClientData( this );
1962   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1963   myPriority = 0.0;
1964
1965   /* load resources for all available meshers */
1966   SMESH::InitAvailableHypotheses();
1967 }
1968
1969 //=============================================================================
1970 /*!
1971  *
1972  */
1973 //=============================================================================
1974 SMESHGUI::~SMESHGUI()
1975 {
1976 }
1977
1978 //=============================================================================
1979 /*!
1980  *
1981  */
1982 //=============================================================================
1983 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1984 {
1985   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1986   if( anApp )
1987     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1988   else
1989     return 0;
1990 }
1991
1992 //=============================================================================
1993 /*!
1994  *
1995  */
1996 //=============================================================================
1997 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1998 {
1999   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2000   if ( !resMgr )
2001     return false;
2002
2003   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
2004   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2005   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2006   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2007   return autoUpdate && !exceeded;
2008 }
2009
2010 //=============================================================================
2011 /*!
2012  *
2013  */
2014 //=============================================================================
2015 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2016                                 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2017 {
2018   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2019   if ( !resMgr )
2020     return false;
2021
2022   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update", false );
2023   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2024   bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2025
2026   SMESH::long_array_var info = theMesh->GetMeshInfo();
2027   long nbOdElems = info[SMDSEntity_0D];
2028   long nbEdges   = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2029   long nbFaces   = info[SMDSEntity_Triangle]   + info[SMDSEntity_Quad_Triangle]   + info[SMDSEntity_BiQuad_Triangle] +
2030                    info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2031                    info[SMDSEntity_Polygon];
2032   long nbVolumes = info[SMDSEntity_Tetra]   + info[SMDSEntity_Quad_Tetra] +
2033                    info[SMDSEntity_Hexa]    + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2034                    info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2035                    info[SMDSEntity_Penta]   + info[SMDSEntity_Quad_Penta] +
2036                    info[SMDSEntity_Polyhedra] +
2037                    info[SMDSEntity_Hexagonal_Prism];
2038   long nbBalls   = info[SMDSEntity_Ball];
2039
2040   long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2041   *nbElements = requestedSize;
2042
2043   *entities = SMESH_Actor::eAllEntity;
2044   *hidden   = 0;
2045
2046   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2047
2048   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2049
2050   if ( incrementalLimit ) {
2051     long total     = 0;
2052
2053     if ( nbOdElems > 0 ) {
2054       if ( total + nbOdElems > updateLimit ) {
2055         *entities = *entities & ~SMESH_Actor::e0DElements;
2056         *hidden = *hidden | SMESH_Actor::e0DElements;
2057       }
2058       else
2059         exceeded = false;
2060     }
2061     total += nbOdElems;
2062
2063     if ( nbEdges > 0 ) {
2064       if ( total + nbEdges > updateLimit ) {
2065         *entities = *entities & ~SMESH_Actor::eEdges;
2066         *hidden = *hidden | SMESH_Actor::eEdges;
2067       }
2068       else
2069         exceeded = false;
2070     }
2071     total += nbEdges;
2072
2073     if ( nbFaces > 0 ) {
2074       if ( total + nbFaces > updateLimit ) {
2075         *entities = *entities & ~SMESH_Actor::eFaces;
2076         *hidden = *hidden | SMESH_Actor::eFaces;
2077       }
2078       else
2079         exceeded = false;
2080     }
2081     total += nbFaces;
2082
2083     if ( nbVolumes > 0 ) {
2084       if ( total + nbVolumes > updateLimit ) {
2085         *entities = *entities & ~SMESH_Actor::eVolumes;
2086         *hidden = *hidden | SMESH_Actor::eVolumes;
2087       }
2088       else
2089         exceeded = false;
2090     }
2091     total += nbVolumes;
2092
2093     if ( nbBalls > 0 ) {
2094       if ( total + nbBalls > updateLimit ) {
2095         *entities = *entities & ~SMESH_Actor::eBallElem;
2096         *hidden = *hidden | SMESH_Actor::eBallElem;
2097       }
2098       else
2099         exceeded = false;
2100     }
2101     total += nbBalls;
2102   }
2103
2104   return autoUpdate && !exceeded;
2105 }
2106
2107 //=============================================================================
2108 /*!
2109  *
2110  */
2111 //=============================================================================
2112 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2113 {
2114   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2115 }
2116
2117 //=============================================================================
2118 /*!
2119  *
2120  */
2121 //=============================================================================
2122 SMESHGUI* SMESHGUI::GetSMESHGUI()
2123 {
2124   SMESHGUI* smeshMod = 0;
2125   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2126   if ( app )
2127   {
2128     CAM_Module* module = app->module( "Mesh" );
2129     smeshMod = dynamic_cast<SMESHGUI*>( module );
2130   }
2131
2132   if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2133   {
2134     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2135     if ( study )
2136     {
2137       _PTR(Study) aStudy = study->studyDS();
2138       if ( aStudy )
2139         GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2140     }
2141   }
2142
2143   return smeshMod;
2144 }
2145
2146 extern "C"
2147 {
2148   Standard_EXPORT SMESHGUI* GetComponentGUI()
2149   {
2150     return SMESHGUI::GetSMESHGUI();
2151   }
2152 }
2153
2154 //=============================================================================
2155 /*!
2156  *
2157  */
2158 //=============================================================================
2159 void SMESHGUI::SetState(int aState)
2160 {
2161   myState = aState;
2162 }
2163
2164 //=============================================================================
2165 /*!
2166  *
2167  */
2168 //=============================================================================
2169 void SMESHGUI::ResetState()
2170 {
2171   myState = -1;
2172 }
2173
2174 //=============================================================================
2175 /*!
2176  *
2177  */
2178 //=============================================================================
2179 void SMESHGUI::EmitSignalDeactivateDialog()
2180 {
2181   emit SignalDeactivateActiveDialog();
2182 }
2183
2184 //=============================================================================
2185 /*!
2186  *
2187  */
2188 //=============================================================================
2189 void SMESHGUI::EmitSignalStudyFrameChanged()
2190 {
2191   emit SignalStudyFrameChanged();
2192 }
2193
2194 //=============================================================================
2195 /*!
2196  *
2197  */
2198 //=============================================================================
2199 void SMESHGUI::EmitSignalCloseAllDialogs()
2200 {
2201   emit SignalCloseAllDialogs();
2202 }
2203
2204 //=============================================================================
2205 /*!
2206  *
2207  */
2208 //=============================================================================
2209 void SMESHGUI::EmitSignalVisibilityChanged()
2210 {
2211   emit SignalVisibilityChanged();
2212 }
2213
2214 //=============================================================================
2215 /*!
2216  *
2217  */
2218 //=============================================================================
2219 QDialog *SMESHGUI::GetActiveDialogBox()
2220 {
2221   return myActiveDialogBox;
2222 }
2223
2224 //=============================================================================
2225 /*!
2226  *
2227  */
2228 //=============================================================================
2229 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2230 {
2231   myActiveDialogBox = (QDialog *) aDlg;
2232   return;
2233 }
2234
2235 //=============================================================================
2236 /*!
2237  *
2238  */
2239 //=============================================================================
2240 SUIT_Desktop* SMESHGUI::desktop()
2241 {
2242   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2243   if( app )
2244     return app->desktop();
2245   else
2246     return 0;
2247 }
2248
2249 //=============================================================================
2250 /*!
2251  *
2252  */
2253 //=============================================================================
2254 SalomeApp_Study* SMESHGUI::activeStudy()
2255 {
2256   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2257   if( app )
2258     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2259   else
2260     return NULL;
2261 }
2262
2263 //=============================================================================
2264 /*!
2265  *
2266  */
2267 //=============================================================================
2268 void SMESHGUI::Modified( bool theIsUpdateActions )
2269 {
2270   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2271     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2272       appStudy->Modified();
2273       if( theIsUpdateActions )
2274         app->updateActions();
2275     }
2276   }
2277 }
2278
2279 //=============================================================================
2280 /*!
2281  *
2282  */
2283 //=============================================================================
2284 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2285 {
2286   /* Here the position is on the bottom right corner - 10 */
2287   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2288   aDlg->adjustSize();
2289   SUIT_Desktop *PP = desktop();
2290   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2291   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2292   return true;
2293 }
2294
2295 //=============================================================================
2296 /*!
2297  *
2298  */
2299 //=============================================================================
2300 static int isStudyLocked(_PTR(Study) theStudy){
2301   return theStudy->GetProperties()->IsLocked();
2302 }
2303
2304 static bool checkLock(_PTR(Study) theStudy) {
2305   if (isStudyLocked(theStudy)) {
2306     SUIT_MessageBox::warning( SMESHGUI::desktop(),
2307                               QObject::tr("WRN_WARNING"),
2308                               QObject::tr("WRN_STUDY_LOCKED") );
2309     return true;
2310   }
2311   return false;
2312 }
2313
2314 //=======================================================================
2315 //function : CheckActiveStudyLocked
2316 //purpose  :
2317 //=======================================================================
2318
2319 bool SMESHGUI::isActiveStudyLocked()
2320 {
2321   _PTR(Study) aStudy = activeStudy()->studyDS();
2322   return checkLock( aStudy );
2323 }
2324
2325 //=============================================================================
2326 /*!
2327  *
2328  */
2329 //=============================================================================
2330 bool SMESHGUI::OnGUIEvent( int theCommandID )
2331 {
2332   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2333   if( !anApp )
2334     return false;
2335
2336   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2337   SUIT_ResourceMgr* mgr = resourceMgr();
2338   if( !mgr )
2339     return false;
2340
2341   if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2342     GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2343   }
2344
2345   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2346   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2347
2348   //QAction* act = action( theCommandID );
2349
2350   switch (theCommandID) {
2351   case 33:                                      // DELETE
2352     if(checkLock(aStudy)) break;
2353     OnEditDelete();
2354     break;
2355
2356   case 116:
2357   case 115:
2358   case 117:
2359   case 118:
2360   case 113:
2361   case 112:
2362   case 111:                                     // IMPORT
2363     {
2364       if(checkLock(aStudy)) break;
2365       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2366       break;
2367     }
2368
2369   case 150:    //MED FILE INFORMATION
2370     {
2371       SALOME_ListIO selected;
2372       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2373       if( aSel )
2374         aSel->selectedObjects( selected );
2375       if( selected.Extent() )
2376       {
2377         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2378         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2379         if ( !aMesh->_is_nil() )
2380         {
2381           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2382           dlg.exec();
2383         }
2384       }
2385       break;
2386     }
2387
2388   case 122:                                     // EXPORT MED
2389   case 121:
2390   case 123:
2391   case 124:
2392   case 125:
2393   case 126:
2394   case 140:
2395   case 141:
2396   case 142:
2397   case 143:
2398   case 144:
2399   case 145:
2400   case 146:
2401   case 147:
2402     {
2403       ::ExportMeshToFile(theCommandID);
2404       break;
2405     }
2406
2407   case 200:                                     // SCALAR BAR
2408     {
2409       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2410       SALOME_ListIO selected;
2411       if( aSel )
2412         aSel->selectedObjects( selected );
2413
2414       if( selected.Extent() ) {
2415         Handle(SALOME_InteractiveObject) anIO = selected.First();
2416         if( anIO->hasEntry() ) {
2417           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2418             anActor->SetControlMode( SMESH_Actor::eNone );
2419 #ifndef DISABLE_PLOT2DVIEWER
2420             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2421 #endif
2422           }
2423         }
2424       }
2425       break;
2426     }
2427   case 201:
2428     {
2429       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2430       break;
2431     }
2432   case 2021:
2433     {
2434       // dump control distribution data to the text file
2435       ::SaveDistribution();
2436       break;
2437     }
2438
2439   case 2022:
2440     {
2441       // show/ distribution
2442       ::ShowDistribution();
2443       break;
2444     }
2445
2446 #ifndef DISABLE_PLOT2DVIEWER
2447   case 2023:
2448     {
2449       // plot distribution
2450       ::PlotDistribution();
2451       break;
2452     }
2453 #endif
2454
2455     // Auto-color
2456   case 1136:
2457     ::AutoColor();
2458   break;
2459
2460   case 1137:
2461     ::DisableAutoColor();
2462   break;
2463
2464   case 1134: // Clipping
2465   case 1133: // Tranparency
2466   case 1132: // Display preferences (colors, shrink size, line width, ...)
2467
2468     // Display Mode
2469   case 215: // Nodes
2470   case 213: // Nodes
2471   case 212: // Nodes
2472   case 211: // Nodes
2473     ::SetDisplayMode(theCommandID, myMarkerMap);
2474   break;
2475
2476   //2D quadratic representation
2477   case 231:
2478   case 232:
2479     ::SetDisplayMode(theCommandID, myMarkerMap);
2480   break;
2481
2482   // Display Entity
2483   case 216: // 0D elements
2484   case 217: // Edges
2485   case 218: // Faces
2486   case 219: // Volumes
2487   case 220: // All Entity
2488   case 222: // Balls
2489     ::SetDisplayEntity(theCommandID);
2490   break;
2491
2492   case 221: // Orientation of faces
2493     {
2494       LightApp_SelectionMgr* mgr = selectionMgr();
2495       SALOME_ListIO selected; mgr->selectedObjects( selected );
2496
2497       SALOME_ListIteratorOfListIO it(selected);
2498       for( ; it.More(); it.Next()) {
2499         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2500         if(anIObject->hasEntry()) {
2501           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2502             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2503           }
2504         }
2505       }
2506       break;
2507     }
2508
2509   case 214:                                     // UPDATE
2510     {
2511       if(checkLock(aStudy)) break;
2512       SUIT_OverrideCursor wc;
2513       try {
2514 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2515         OCC_CATCH_SIGNALS;
2516 #endif
2517         SMESH::UpdateView();
2518       }
2519       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2520         SMESH::OnVisuException();
2521       }
2522       catch (...) { // PAL16774 (Crash after display of many groups)
2523         SMESH::OnVisuException();
2524       }
2525
2526       SALOME_ListIO l;
2527       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2528       aSel->selectedObjects( l );
2529       aSel->setSelectedObjects( l );
2530       break;
2531     }
2532
2533   case 300:                                     // ERASE
2534   case 301:                                     // DISPLAY
2535   case 302:                                     // DISPLAY ONLY
2536     {
2537       SMESH::EDisplaing anAction;
2538       switch (theCommandID) {
2539       case 300: anAction = SMESH::eErase; break;
2540       case 301: anAction = SMESH::eDisplay; break;
2541       case 302: anAction = SMESH::eDisplayOnly; break;
2542       }
2543
2544       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2545       SALOME_ListIO sel_objects, to_process;
2546       if (aSel)
2547         aSel->selectedObjects( sel_objects );
2548
2549       if( theCommandID==302 )
2550       {
2551         MESSAGE("anAction = SMESH::eDisplayOnly");
2552         startOperation( myEraseAll );
2553       }
2554
2555       extractContainers( sel_objects, to_process );
2556
2557       try {
2558 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2559         OCC_CATCH_SIGNALS;
2560 #endif
2561         if (vtkwnd) {
2562           SALOME_ListIteratorOfListIO It( to_process );
2563           for ( ; It.More(); It.Next()) {
2564             MESSAGE("---");
2565             Handle(SALOME_InteractiveObject) IOS = It.Value();
2566             if (IOS->hasEntry()) {
2567               MESSAGE("---");
2568               if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2569                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2570                 break; // PAL16774 (Crash after display of many groups)
2571               }
2572               if (anAction == SMESH::eDisplayOnly)
2573               {
2574                 MESSAGE("anAction = SMESH::eDisplayOnly");
2575                 anAction = SMESH::eDisplay;
2576               }
2577             }
2578           }
2579         }
2580
2581         // PAL13338 + PAL15161 -->
2582         if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2583           MESSAGE("anAction = SMESH::eDisplayOnly");
2584           SMESH::UpdateView();
2585           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2586         }
2587         // PAL13338 + PAL15161 <--
2588       }
2589       catch (...) { // PAL16774 (Crash after display of many groups)
2590         SMESH::OnVisuException();
2591       }
2592
2593       if (anAction == SMESH::eErase) {
2594         MESSAGE("anAction == SMESH::eErase");
2595         SALOME_ListIO l1;
2596         aSel->setSelectedObjects( l1 );
2597       }
2598       else
2599         aSel->setSelectedObjects( to_process );
2600
2601       break;
2602     }
2603
2604   case 4000:                                    // NODES
2605     {
2606       if(checkLock(aStudy)) break;
2607
2608       if ( vtkwnd ) {
2609         EmitSignalDeactivateDialog();
2610
2611         ( new SMESHGUI_NodesDlg( this ) )->show();
2612       }
2613       else {
2614         SUIT_MessageBox::warning(desktop(),
2615                                  tr("SMESH_WRN_WARNING"),
2616                                  tr("SMESH_WRN_VIEWER_VTK"));
2617       }
2618       break;
2619     }
2620
2621   case 2151:  // FILTER
2622   {
2623     if ( vtkwnd )
2624     {
2625       EmitSignalDeactivateDialog();
2626       ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2627     }
2628     break;
2629   }
2630
2631   case 701: // COMPUTE MESH
2632   case 711: // PRECOMPUTE MESH
2633   case 712: // EVALUATE MESH
2634   case 713: // MESH ORDER
2635   case 702: // Create mesh
2636   case 703: // Create sub-mesh
2637   case 704: // Edit mesh/sub-mesh
2638     startOperation( theCommandID );
2639     break;
2640   case 705: // copy mesh
2641     {
2642       if (checkLock(aStudy)) break;
2643       EmitSignalDeactivateDialog();
2644       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2645     }
2646     break;
2647   case 710: // Build compound mesh
2648     {
2649       if (checkLock(aStudy)) break;
2650       EmitSignalDeactivateDialog();
2651       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2652     }
2653     break;
2654
2655   case 407: // DIAGONAL INVERSION
2656   case 408: // Delete diagonal
2657     {
2658       if ( !vtkwnd )
2659       {
2660         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2661                                   tr( "NOT_A_VTK_VIEWER" ) );
2662         break;
2663       }
2664
2665       if ( checkLock( aStudy ) )
2666         break;
2667
2668       /*Standard_Boolean aRes;
2669       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2670       if ( aMesh->_is_nil() )
2671       {
2672         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2673           tr( "SMESH_BAD_SELECTION" ) );
2674         break;
2675       }
2676       */
2677       EmitSignalDeactivateDialog();
2678       if ( theCommandID == 407 )
2679         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2680       else
2681         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2682       break;
2683     }
2684   case 409: // Change orientation
2685   case 410: // Union of triangles
2686   case 411: // Cutting of quadrangles
2687   case 419: // Splitting volumes into tetrahedra
2688     {
2689       if ( !vtkwnd )
2690       {
2691         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2692                                   tr( "NOT_A_VTK_VIEWER" ) );
2693         break;
2694       }
2695
2696       if ( checkLock( aStudy ) )
2697         break;
2698
2699       EmitSignalDeactivateDialog();
2700       SMESHGUI_MultiEditDlg* aDlg = NULL;
2701       if ( theCommandID == 409 )
2702         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2703       else if ( theCommandID == 410 )
2704         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2705       else if ( theCommandID == 419 )
2706         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2707       else
2708         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2709
2710       aDlg->show();
2711       break;
2712     }
2713   case 412: // Smoothing
2714     {
2715       if(checkLock(aStudy)) break;
2716       if( vtkwnd ) {
2717         EmitSignalDeactivateDialog();
2718         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2719       }
2720       else {
2721         SUIT_MessageBox::warning(desktop(),
2722                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2723       }
2724       break;
2725     }
2726   case 413: // Extrusion
2727     {
2728       if (checkLock(aStudy)) break;
2729       if (vtkwnd) {
2730         EmitSignalDeactivateDialog();
2731         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2732       } else {
2733         SUIT_MessageBox::warning(desktop(),
2734                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2735       }
2736       break;
2737     }
2738   case 414: // Revolution
2739     {
2740       if(checkLock(aStudy)) break;
2741       if( vtkwnd ) {
2742         EmitSignalDeactivateDialog();
2743         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2744       }
2745       else {
2746         SUIT_MessageBox::warning(desktop(),
2747                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2748       }
2749       break;
2750     }
2751   case 415: // Pattern mapping
2752     {
2753       if ( checkLock( aStudy ) )
2754         break;
2755       if ( vtkwnd )
2756       {
2757         EmitSignalDeactivateDialog();
2758         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2759       }
2760       else {
2761         SUIT_MessageBox::warning(desktop(),
2762                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2763       }
2764       break;
2765     }
2766   case 416: // Extrusion along a path
2767     {
2768       if (checkLock(aStudy)) break;
2769       if (vtkwnd) {
2770         EmitSignalDeactivateDialog();
2771         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2772       } else {
2773         SUIT_MessageBox::warning(desktop(),
2774                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2775       }
2776       break;
2777     }
2778   case 417: // Convert mesh to quadratic
2779   case 418: // create 2D mesh from 3D
2780   case 420: // Reorient faces
2781   case 806: // CREATE GEO GROUP
2782     {
2783       startOperation( theCommandID );
2784       break;
2785     }
2786   case 801:                                     // CREATE GROUP
2787     {
2788       if ( !vtkwnd )
2789       {
2790         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2791                                   tr( "NOT_A_VTK_VIEWER" ) );
2792         break;
2793       }
2794
2795       if(checkLock(aStudy)) break;
2796       EmitSignalDeactivateDialog();
2797       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2798
2799       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2800       SALOME_ListIO selected;
2801       if( aSel )
2802         aSel->selectedObjects( selected );
2803
2804       int nbSel = selected.Extent();
2805       if (nbSel == 1) {
2806         // check if mesh is selected
2807         aMesh = SMESH::GetMeshByIO( selected.First() );
2808       }
2809       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2810       aDlg->show();
2811       break;
2812     }
2813
2814   case 802:                                     // CONSTRUCT GROUP
2815     {
2816       if ( !vtkwnd )
2817       {
2818         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2819                                   tr( "NOT_A_VTK_VIEWER" ) );
2820         break;
2821       }
2822
2823       if(checkLock(aStudy)) break;
2824       EmitSignalDeactivateDialog();
2825
2826       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2827       SALOME_ListIO selected;
2828       if( aSel )
2829         aSel->selectedObjects( selected );
2830
2831       int nbSel = selected.Extent();
2832       if (nbSel == 1) {
2833         // check if submesh is selected
2834         Handle(SALOME_InteractiveObject) IObject = selected.First();
2835         if (IObject->hasEntry()) {
2836           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2837           if( aSObj ) {
2838             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2839             if (!aSubMesh->_is_nil()) {
2840               try {
2841                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2842                 // get submesh elements list by types
2843                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2844                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2845                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2846                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2847                 // create group for each type o elements
2848                 QString aName = IObject->getName();
2849                 QStringList anEntryList;
2850                 if (aNodes->length() > 0) {
2851                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2852                   aGroup->Add(aNodes.inout());
2853                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2854                     anEntryList.append( aSObject->GetID().c_str() );
2855                 }
2856                 if (aEdges->length() > 0) {
2857                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2858                   aGroup->Add(aEdges.inout());
2859                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2860                     anEntryList.append( aSObject->GetID().c_str() );
2861                 }
2862                 if (aFaces->length() > 0) {
2863                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2864                   aGroup->Add(aFaces.inout());
2865                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2866                     anEntryList.append( aSObject->GetID().c_str() );
2867                 }
2868                 if (aVolumes->length() > 0) {
2869                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2870                   aGroup->Add(aVolumes.inout());
2871                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2872                     anEntryList.append( aSObject->GetID().c_str() );
2873                 }
2874                 updateObjBrowser();
2875                 anApp->browseObjects( anEntryList );
2876               }
2877               catch(const SALOME::SALOME_Exception & S_ex){
2878                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2879               }
2880             }
2881           }
2882         }
2883       }
2884       else if(nbSel==0) {
2885         SUIT_MessageBox::warning(desktop(),
2886                                  tr("SMESH_WRN_WARNING"),
2887                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2888       }
2889       break;
2890     }
2891
2892   case 803:                                     // EDIT GROUP
2893     {
2894       if ( !vtkwnd )
2895       {
2896         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2897                                   tr( "NOT_A_VTK_VIEWER" ) );
2898         break;
2899       }
2900
2901       if(checkLock(aStudy)) break;
2902       EmitSignalDeactivateDialog();
2903
2904       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2905       SALOME_ListIO selected;
2906       if( aSel )
2907         aSel->selectedObjects( selected );
2908
2909       SALOME_ListIteratorOfListIO It (selected);
2910       int nbSelectedGroups = 0;
2911       for ( ; It.More(); It.Next() )
2912       {
2913         SMESH::SMESH_GroupBase_var aGroup =
2914           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2915         if (!aGroup->_is_nil()) {
2916           nbSelectedGroups++;
2917           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2918           aDlg->show();
2919         }
2920       }
2921       if (nbSelectedGroups == 0)
2922         {
2923           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2924           aDlg->show();
2925         }
2926       break;
2927     }
2928
2929   case 804:                                     // Add elements to group
2930     {
2931       if(checkLock(aStudy)) break;
2932       if (myState == 800) {
2933         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2934         if (aDlg) aDlg->onAdd();
2935       }
2936       break;
2937     }
2938
2939   case 805:                                     // Remove elements from group
2940     {
2941       if(checkLock(aStudy)) break;
2942       if (myState == 800) {
2943         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2944         if (aDlg) aDlg->onRemove();
2945       }
2946       break;
2947     }
2948
2949   case 815:                                     // Edit GEOM GROUP as standalone
2950     {
2951       if ( !vtkwnd )
2952       {
2953         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2954                                   tr( "NOT_A_VTK_VIEWER" ) );
2955         break;
2956       }
2957
2958       if(checkLock(aStudy)) break;
2959       EmitSignalDeactivateDialog();
2960
2961       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2962       SALOME_ListIO selected;
2963       if( aSel )
2964         aSel->selectedObjects( selected );
2965
2966       SALOME_ListIteratorOfListIO It (selected);
2967       for ( ; It.More(); It.Next() )
2968       {
2969         SMESH::SMESH_GroupOnGeom_var aGroup =
2970           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2971         if (!aGroup->_is_nil()) {
2972           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2973           aDlg->show();
2974         }
2975         else
2976         {
2977           SMESH::SMESH_GroupOnFilter_var aGroup =
2978             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2979           if (!aGroup->_is_nil()) {
2980             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2981             aDlg->show();
2982           }
2983         }
2984       }
2985       break;
2986     }
2987
2988     case 810: // Union Groups
2989     case 811: // Intersect groups
2990     case 812: // Cut groups
2991     {
2992       if ( !vtkwnd )
2993       {
2994         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2995                                   tr( "NOT_A_VTK_VIEWER" ) );
2996         break;
2997       }
2998
2999       if ( checkLock( aStudy ) )
3000         break;
3001
3002       EmitSignalDeactivateDialog();
3003
3004       SMESHGUI_GroupOpDlg* aDlg = 0;
3005       if ( theCommandID == 810 )
3006         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3007       else if ( theCommandID == 811 )
3008         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3009       else
3010         aDlg = new SMESHGUI_CutGroupsDlg( this );
3011
3012       aDlg->show();
3013
3014       break;
3015     }
3016
3017     case 814: // Create groups of entities from existing groups of superior dimensions
3018     {
3019       if ( checkLock( aStudy ) )
3020         break;
3021
3022       EmitSignalDeactivateDialog();
3023       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3024       aDlg->show();
3025
3026       break;
3027     }
3028
3029     case 813: // Delete groups with their contents
3030     {
3031       if ( !vtkwnd )
3032       {
3033         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3034                                   tr( "NOT_A_VTK_VIEWER" ) );
3035         break;
3036       }
3037
3038       if ( checkLock( aStudy ) )
3039         break;
3040
3041       EmitSignalDeactivateDialog();
3042
3043       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3044       break;
3045     }
3046
3047   case 900:                                     // MESH INFOS
3048   case 903:                                     // WHAT IS
3049     {
3050       int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3051       EmitSignalDeactivateDialog();
3052       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3053       SALOME_ListIO selected;
3054       if( aSel )
3055         aSel->selectedObjects( selected );
3056
3057       if ( selected.Extent() > 1 ) { // a dlg for each IO
3058         SALOME_ListIteratorOfListIO It( selected );
3059         for ( ; It.More(); It.Next() ) {
3060           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3061           dlg->showInfo( It.Value() );
3062           dlg->show();
3063         }
3064       }
3065       else {