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