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 edgeWidth    = 1;
1320         int outlineWidth = 1;
1321         double shrinkCoef = 0.0;
1322         double orientationScale = 0.0;
1323         bool orientation3d = false;
1324         VTK::MarkerType markerType = VTK::MT_NONE;
1325         VTK::MarkerScale markerScale = VTK::MS_NONE;
1326         int markerId = 0;
1327         bool hasNodes = false;
1328         int presentEntities = 0;
1329         bool firstTime  = true;
1330
1331         SALOME_ListIteratorOfListIO It( selected );
1332         for ( ; It.More(); It.Next() ) {
1333           Handle(SALOME_InteractiveObject) IObject = It.Value();
1334           if ( !IObject->hasEntry() ) continue;
1335           SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1336           if ( !anActor || !anActor->GetObject() ) continue;
1337
1338           if ( firstTime ) {
1339             // nodes: color, marker
1340             anActor->GetNodeColor( color[0], color[1], color[2] );
1341             nodeColor.setRgbF( color[0], color[1], color[2] );
1342             markerType  = anActor->GetMarkerType();
1343             markerScale = anActor->GetMarkerScale();
1344             markerId    = anActor->GetMarkerTexture();
1345             // edges: color, width
1346             anActor->GetEdgeColor( color[0], color[1], color[2] );
1347             edgeColor.setRgbF( color[0], color[1], color[2] );
1348             edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1349             // faces: front color, back color (delta)
1350             anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1351             faceColor.setRgbF( color[0], color[1], color[2] );
1352             // faces: front color, back color (delta)
1353             anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1354             volumeColor.setRgbF( color[0], color[1], color[2] );
1355             // 0d elements: color, size
1356             anActor->Get0DColor( color[0], color[1], color[2] );
1357             elem0dColor.setRgbF( color[0], color[1], color[2] );
1358             elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1359             // balls: color, size
1360             anActor->GetBallColor( color[0], color[1], color[2] );
1361             ballColor.setRgbF( color[0], color[1], color[2] );
1362             ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1363             // outlines: color
1364             anActor->GetOutlineColor( color[0], color[1], color[2] );
1365             outlineColor.setRgbF( color[0], color[1], color[2] );
1366             outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1367             // orientation vectors: color, scale, 3d flag
1368             anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1369             orientationColor.setRgbF( color[0], color[1], color[2] );
1370             orientationScale = anActor->GetFacesOrientationScale();
1371             orientation3d = anActor->GetFacesOrientation3DVectors();
1372             // shrink factor
1373             shrinkCoef = anActor->GetShrinkFactor();
1374           }
1375
1376           firstTime = false; // we only take properties from first object (for performance reasons)
1377
1378           if ( !hasNodes )
1379             hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1380           if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1381             presentEntities = presentEntities | SMESH_Actor::eEdges;
1382           if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1383             presentEntities = presentEntities | SMESH_Actor::eFaces;
1384           if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1385             presentEntities = presentEntities | SMESH_Actor::eVolumes;
1386           if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1387             presentEntities = presentEntities | SMESH_Actor::e0DElements;
1388           if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1389             presentEntities = presentEntities | SMESH_Actor::eBallElem;
1390
1391           // as we know that all types of elements are present, we can exit the loop
1392           if ( presentEntities == SMESH_Actor::eAllEntity )
1393             break;
1394         }
1395
1396         SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1397         // nodes: color, marker
1398         dlg.setNodeColor( nodeColor );
1399         if( markerType != VTK::MT_USER )
1400           dlg.setNodeMarker( markerType, markerScale );
1401         else
1402           dlg.setNodeCustomMarker( markerId );
1403         // edges: color, line width
1404         dlg.setEdgeColor( edgeColor );
1405         dlg.setEdgeWidth( edgeWidth );
1406         // faces: front color, back color
1407         dlg.setFaceColor( faceColor, deltaF );
1408         // volumes: normal color, reversed color
1409         dlg.setVolumeColor( volumeColor, deltaV );
1410         // outlines: color, line width
1411         dlg.setOutlineColor( outlineColor );
1412         dlg.setOutlineWidth( outlineWidth );
1413         // 0d elements: color, size
1414         dlg.setElem0dColor( elem0dColor );
1415         dlg.setElem0dSize( elem0dSize );
1416         // balls: color, size
1417         dlg.setBallColor( ballColor );
1418         dlg.setBallSize( ballSize );
1419         // orientation: color, scale, 3d flag
1420         dlg.setOrientationColor( orientationColor );
1421         dlg.setOrientationSize( int( orientationScale * 100. ) );
1422         dlg.setOrientation3d( orientation3d );
1423         // shrink: scale factor
1424         dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1425         // hide unused controls
1426         dlg.showControls( presentEntities, hasNodes );
1427
1428         if ( dlg.exec() ) {
1429           nodeColor        = dlg.nodeColor();
1430           markerType       = dlg.nodeMarkerType();
1431           markerScale      = dlg.nodeMarkerScale();
1432           markerId         = dlg.nodeMarkerId();
1433           edgeColor        = dlg.edgeColor();
1434           edgeWidth        = dlg.edgeWidth();
1435           faceColor        = dlg.faceColor();
1436           deltaF           = dlg.faceColorDelta();
1437           volumeColor      = dlg.volumeColor();
1438           deltaV           = dlg.volumeColorDelta();
1439           outlineColor     = dlg.outlineColor();
1440           outlineWidth     = dlg.outlineWidth();
1441           elem0dColor      = dlg.elem0dColor();
1442           elem0dSize       = dlg.elem0dSize();
1443           ballColor        = dlg.ballColor();
1444           ballSize         = dlg.ballSize();
1445           orientationColor = dlg.orientationColor();
1446           orientationScale = dlg.orientationSize() / 100.;
1447           orientation3d    = dlg.orientation3d();
1448           shrinkCoef       = dlg.shrinkCoef() / 100.;
1449
1450           // store point markers map that might be changed by the user
1451           theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1452
1453           // set properties from dialog box to the presentations
1454           SALOME_ListIteratorOfListIO It( selected );
1455           for ( ; It.More(); It.Next() ) {
1456             Handle(SALOME_InteractiveObject) IObject = It.Value();
1457             if ( !IObject->hasEntry() ) continue;
1458             SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1459             if ( !anActor ) continue;
1460
1461             // nodes: color, marker
1462             anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1463             if ( markerType != VTK::MT_USER ) {
1464               anActor->SetMarkerStd( markerType, markerScale );
1465             }
1466             else {
1467               const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1468               VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1469               if ( iter != markerMap.end() )
1470                 anActor->SetMarkerTexture( markerId, iter->second.second );
1471             }
1472             // volumes: normal color, reversed color (delta)
1473             anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1474             // faces: front color, back color (delta)
1475             anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1476             // edges: color, width
1477             anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1478             anActor->SetLineWidth( edgeWidth );
1479             // outlines: color
1480             anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1481             anActor->SetOutlineWidth( outlineWidth );
1482             // 0D elements: color, size
1483             anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1484             anActor->Set0DSize( elem0dSize );
1485             // balls: color, size
1486             anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1487             anActor->SetBallSize( ballSize );
1488             // orientation: color, scale, 3d flag
1489             anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1490             anActor->SetFacesOrientationScale( orientationScale );
1491             anActor->SetFacesOrientation3DVectors( orientation3d );
1492             // shrink factor
1493             anActor->SetShrinkFactor( shrinkCoef );
1494
1495             // for groups, set also proper color
1496             SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1497             if ( !aGroupObject->_is_nil() ) {
1498               SMESH::ElementType anElementType = aGroupObject->GetType();
1499               QColor aColor;
1500               switch( anElementType ) {
1501               case SMESH::NODE:
1502                 aColor = nodeColor; break;
1503               case SMESH::EDGE:
1504                 aColor = edgeColor; break;
1505               case SMESH::FACE:
1506                 aColor = faceColor; break;
1507               case SMESH::VOLUME:
1508                 aColor = volumeColor; break;
1509               case SMESH::ELEM0D:
1510                 aColor = elem0dColor; break;
1511               case SMESH::BALL:
1512                 aColor = ballColor; break;
1513               default: break;
1514               }
1515
1516               if ( aColor.isValid() ) {
1517                 SALOMEDS::Color aGroupColor;
1518                 aGroupColor.R = aColor.redF();
1519                 aGroupColor.G = aColor.greenF();
1520                 aGroupColor.B = aColor.blueF();
1521                 aGroupObject->SetColor( aGroupColor );
1522               }
1523             } // if ( !aGroupObject->_is_nil() )
1524           } // for ( ; It.More(); It.Next() )
1525           SMESH::RepaintCurrentView();
1526         } // if ( dlg.exec() )
1527         return;
1528       } // case 1132:
1529       } // switch(theCommandID)
1530       SALOME_ListIteratorOfListIO It( selected );
1531       for( ; It.More(); It.Next()){
1532         Handle(SALOME_InteractiveObject) IObject = It.Value();
1533         if(IObject->hasEntry()){
1534           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1535             switch(theCommandID){
1536             case 211:
1537               anActor->SetRepresentation(SMESH_Actor::eEdge);
1538               break;
1539             case 212:
1540               anActor->SetRepresentation(SMESH_Actor::eSurface);
1541               break;
1542             case 213:
1543               if(anActor->IsShrunk())
1544                 anActor->UnShrink();
1545               else
1546                 anActor->SetShrink();
1547               break;
1548             case 215:
1549               anActor->SetRepresentation(SMESH_Actor::ePoint);
1550               break;
1551             case 231:
1552               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1553                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1554               break;
1555             case 232:
1556               if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1557                 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1558               break;
1559             }
1560           }
1561         }
1562       }
1563       SMESH::RepaintCurrentView();
1564     }
1565   }
1566
1567   void Control( int theCommandID )
1568   {
1569     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1570     SALOME_ListIO selected;
1571     if( aSel )
1572       aSel->selectedObjects( selected );
1573
1574     if( !selected.IsEmpty() ){
1575       Handle(SALOME_InteractiveObject) anIO = selected.First();
1576       if(!anIO.IsNull()){
1577         SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1578         if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1579           switch ( theCommandID ){
1580           case 6001:
1581             aControl = SMESH_Actor::eLength;
1582             break;
1583           case 6018:
1584             aControl = SMESH_Actor::eLength2D;
1585             break;
1586           case 6002:
1587             aControl = SMESH_Actor::eFreeEdges;
1588             break;
1589           case 6003:
1590             aControl = SMESH_Actor::eFreeBorders;
1591             break;
1592           case 6004:
1593             aControl = SMESH_Actor::eMultiConnection;
1594             break;
1595           case 6005:
1596             aControl = SMESH_Actor::eFreeNodes;
1597             break;
1598           case 6019:
1599             aControl = SMESH_Actor::eMultiConnection2D;
1600             break;
1601           case 6011:
1602             aControl = SMESH_Actor::eArea;
1603             break;
1604           case 6012:
1605             aControl = SMESH_Actor::eTaper;
1606             break;
1607           case 6013:
1608             aControl = SMESH_Actor::eAspectRatio;
1609             break;
1610           case 6017:
1611             aControl = SMESH_Actor::eAspectRatio3D;
1612             break;
1613           case 6014:
1614             aControl = SMESH_Actor::eMinimumAngle;
1615             break;
1616           case 6015:
1617             aControl = SMESH_Actor::eWarping;
1618             break;
1619           case 6016:
1620             aControl = SMESH_Actor::eSkew;
1621             break;
1622           case 6009:
1623             aControl = SMESH_Actor::eVolume3D;
1624             break;
1625           case 6021:
1626             aControl = SMESH_Actor::eFreeFaces;
1627             break;
1628           case 6022:
1629             aControl = SMESH_Actor::eMaxElementLength2D;
1630             break;
1631           case 6023:
1632             aControl = SMESH_Actor::eMaxElementLength3D;
1633             break;
1634           case 6024:
1635             aControl = SMESH_Actor::eBareBorderVolume;
1636             break;
1637           case 6025:
1638             aControl = SMESH_Actor::eBareBorderFace;
1639             break;
1640           case 6026:
1641             aControl = SMESH_Actor::eOverConstrainedVolume;
1642             break;
1643           case 6027:
1644             aControl = SMESH_Actor::eOverConstrainedFace;
1645             break;
1646           case 6028:
1647             aControl = SMESH_Actor::eCoincidentNodes;
1648             break;
1649           case 6029:
1650             aControl = SMESH_Actor::eCoincidentElems1D;
1651             break;
1652           case 6030:
1653             aControl = SMESH_Actor:: eCoincidentElems2D;
1654             break;
1655           case 6031:
1656             aControl = SMESH_Actor::eCoincidentElems3D;
1657             break;
1658           }
1659
1660           anActor->SetControlMode(aControl);
1661           anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1662           SMESH::RepaintCurrentView();
1663 #ifndef DISABLE_PLOT2DVIEWER
1664           if(anActor->GetPlot2Histogram()) {
1665             SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1666             QString functorName = functorToString( anActor->GetFunctor());
1667             QString aHistogramName("%1 : %2");
1668             aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1669             aHistogram->setName(aHistogramName);
1670             aHistogram->setHorTitle(functorName);
1671             SMESH::ProcessIn2DViewers(anActor);
1672           }
1673 #endif
1674         }
1675       }
1676     }
1677   }
1678
1679
1680   bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1681                    SMESH::MeshObjectType                           theType,
1682                    const QString                            theInTypeName,
1683                    QString &                                theOutTypeName)
1684   {
1685     SMESH_TypeFilter aTypeFilter( theType );
1686     QString entry;
1687     if( !theIO.IsNull() )
1688     {
1689       entry = theIO->getEntry();
1690       LightApp_DataOwner owner( entry );
1691       if ( aTypeFilter.isOk( &owner )) {
1692         theOutTypeName = theInTypeName;
1693         return true;
1694       }
1695     }
1696     return false;
1697   }
1698
1699
1700   QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1701   {
1702     _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1703     _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1704     if (aSObj) {
1705       _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1706       CORBA::String_var anID = aSComp->GetID().c_str();
1707       if (!strcmp(anID.in(),theIO->getEntry()))
1708         return "Component";
1709     }
1710
1711     QString aTypeName;
1712     if (
1713         CheckOIType ( theIO, SMESH::HYPOTHESIS,    "Hypothesis", aTypeName ) ||
1714         CheckOIType ( theIO, SMESH::ALGORITHM,     "Algorithm",  aTypeName ) ||
1715         CheckOIType ( theIO, SMESH::MESH,          "Mesh",       aTypeName ) ||
1716         CheckOIType ( theIO, SMESH::SUBMESH,       "SubMesh",    aTypeName ) ||
1717         CheckOIType ( theIO, SMESH::GROUP,         "Group",      aTypeName )
1718         )
1719       return aTypeName;
1720
1721     return "NoType";
1722   }
1723
1724
1725   QString CheckHomogeneousSelection()
1726   {
1727     //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1728     LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1729     SALOME_ListIO selected;
1730     if( aSel )
1731       aSel->selectedObjects( selected );
1732
1733     QString RefType = CheckTypeObject(selected.First());
1734     SALOME_ListIteratorOfListIO It(selected);
1735     for ( ; It.More(); It.Next())
1736     {
1737       Handle(SALOME_InteractiveObject) IObject = It.Value();
1738       QString Type = CheckTypeObject(IObject);
1739       if (Type.compare(RefType) != 0)
1740         return "Heterogeneous Selection";
1741     }
1742
1743     return RefType;
1744   }
1745
1746 } //namespace
1747
1748 void SMESHGUI::OnEditDelete()
1749 {
1750   // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1751   LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1752   SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1753
1754   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1755   _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1756   _PTR(GenericAttribute) anAttr;
1757   _PTR(AttributeIOR) anIOR;
1758
1759   int objectCount = 0;
1760   QString aNameList;
1761   QString aParentComponent = QString::null;
1762   Handle(SALOME_InteractiveObject) anIO;
1763   for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1764   {
1765     anIO = anIt.Value();
1766     QString cur = anIO->getComponentDataType();
1767     _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1768     if (aSO) {
1769       // check if object is reference
1770       _PTR(SObject) aRefSObj;
1771       aNameList.append("\n    - ");
1772       if ( aSO->ReferencedObject( aRefSObj ) ) {
1773         QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1774         aNameList.append( aRefName );
1775         cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1776       }
1777       else
1778         aNameList.append(anIO->getName());
1779       objectCount++;
1780     }
1781
1782     if( aParentComponent.isNull() )
1783       aParentComponent = cur;
1784     else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1785       aParentComponent = "";
1786   }
1787
1788   if ( objectCount == 0 )
1789     return; // No Valid Objects Selected
1790
1791   if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
1792     SUIT_MessageBox::warning( SMESHGUI::desktop(),
1793                               QObject::tr("ERR_ERROR"),
1794                               QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1795     return;
1796   }
1797   // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1798   if (SUIT_MessageBox::warning
1799       (SMESHGUI::desktop(),
1800        QObject::tr("SMESH_WRN_WARNING"),
1801        QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1802        SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1803        SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1804     return;
1805
1806   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1807
1808   // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1809   // then treat them all starting from the deepest objects (at list back)
1810   std::list< _PTR(SObject) > listSO;
1811   SALOME_ListIteratorOfListIO It(selected);
1812   for( ; It.More(); It.Next()) // loop on selected IO's
1813   {
1814     Handle(SALOME_InteractiveObject) IObject = It.Value();
1815     if(IObject->hasEntry()) {
1816       _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1817
1818       // disable removal of "SMESH" component object
1819       if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1820         anIOR = anAttr;
1821         if ( engineIOR() == anIOR->Value().c_str() )
1822           continue;
1823       }
1824       //Check the referenced object
1825       _PTR(SObject) aRefSObject;
1826       if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1827         aSO = aRefSObject; // Delete main Object instead of reference
1828
1829       listSO.push_back( aSO );
1830       std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1831       for ( ; itSO != listSO.end(); ++itSO ) {
1832         _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1833         for (it->InitEx(false); it->More(); it->Next())
1834           listSO.push_back( it->Value() );
1835       }
1836     }
1837   }
1838   // Check if none of objects to delete is referred from outside
1839   std::list< _PTR(SObject) >::reverse_iterator ritSO;
1840   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1841   {
1842     _PTR(SObject) SO = *ritSO;
1843     if ( !SO ) continue;
1844     std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO  );
1845     for (size_t i = 0; i < aReferences.size(); i++) {
1846       _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1847       std::string type = aComponent->ComponentDataType();
1848       if ( type != "SMESH" )
1849       {
1850         SUIT_MessageBox::warning( anApp->desktop(),
1851                                   QObject::tr("WRN_WARNING"),
1852                                   QObject::tr("DEP_OBJECT") );
1853         return; // outside SMESH, there is an object depending on a SMESH object
1854       }
1855     }
1856   }
1857
1858   // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1859   for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1860   {
1861     Handle(SALOME_InteractiveObject) IObject = It.Value();
1862     SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1863     if ( !mesh->_is_nil() )
1864       mesh->Clear();
1865   }
1866
1867   // Treat SO's in the list starting from the back
1868   aStudyBuilder->NewCommand();  // There is a transaction
1869   for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1870   {
1871     _PTR(SObject) SO = *ritSO;
1872     if ( !SO ) continue;
1873     std::string anEntry = SO->GetID();
1874
1875     /** Erase graphical object and remove all its data **/
1876     if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1877       SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1878     }
1879     /** Remove an object from data structures **/
1880     SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1881     SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1882     if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
1883       SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1884       aMesh->RemoveGroup( aGroup );
1885     }
1886     else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
1887       SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1888       aMesh->RemoveSubMesh( aSubMesh );
1889
1890       _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1891       if (aMeshSO)
1892         SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1893     }
1894     else {
1895       Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1896         ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1897       QString objType = CheckTypeObject(IObject);
1898       if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1899         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1900         aStudyBuilder->RemoveObjectWithChildren( SO );
1901       }
1902       else {// default action: remove SObject from the study
1903         // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1904         //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1905         //op->start();
1906         aStudyBuilder->RemoveObjectWithChildren( SO );
1907         //op->finish();
1908       }
1909     }
1910   } /* listSO back loop */
1911
1912   aStudyBuilder->CommitCommand();
1913
1914   /* Clear any previous selection */
1915   SALOME_ListIO l1;
1916   aSel->setSelectedObjects( l1 );
1917
1918   SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1919 }
1920
1921 extern "C" {
1922   SMESHGUI_EXPORT CAM_Module* createModule()
1923   {
1924     return new SMESHGUI();
1925   }
1926
1927   SMESHGUI_EXPORT  char* getModuleVersion() {
1928     return (char*)SMESH_VERSION_STR;
1929   }
1930 }
1931
1932 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1933
1934 //=============================================================================
1935 /*!
1936  *
1937  */
1938 //=============================================================================
1939 SMESHGUI::SMESHGUI() :
1940 SalomeApp_Module( "SMESH" )
1941 {
1942   if ( CORBA::is_nil( myComponentSMESH ) )
1943   {
1944     CORBA::Boolean anIsEmbeddedMode;
1945     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1946     MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1947
1948     //  0019923: EDF 765 SMESH : default values of hypothesis
1949     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1950     int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1951     myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1952     nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1953     myComponentSMESH->SetDefaultNbSegments( nbSeg );
1954
1955     const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1956     for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1957       if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1958       {
1959         QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1960         myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1961       }
1962   }
1963
1964   myActiveDialogBox = 0;
1965   myFilterLibraryDlg = 0;
1966   myState = -1;
1967   myDisplayer = 0;
1968
1969   myEventCallbackCommand = vtkCallbackCommand::New();
1970   myEventCallbackCommand->Delete();
1971   myEventCallbackCommand->SetClientData( this );
1972   myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1973   myPriority = 0.0;
1974
1975   /* load resources for all available meshers */
1976   SMESH::InitAvailableHypotheses();
1977
1978   MPLMathText_Disabler d; // disable vtkMatplotlibMathTextUtilities
1979 }
1980
1981 //=============================================================================
1982 /*!
1983  *
1984  */
1985 //=============================================================================
1986 SMESHGUI::~SMESHGUI()
1987 {
1988 }
1989
1990 //=============================================================================
1991 /*!
1992  *
1993  */
1994 //=============================================================================
1995 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1996 {
1997   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1998   if( anApp )
1999     return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2000   else
2001     return 0;
2002 }
2003
2004 //=============================================================================
2005 /*!
2006  *
2007  */
2008 //=============================================================================
2009 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2010 {
2011   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2012   if ( !resMgr )
2013     return false;
2014
2015   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
2016   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2017   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2018   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2019   return autoUpdate && !exceeded;
2020 }
2021
2022 //=============================================================================
2023 /*!
2024  *
2025  */
2026 //=============================================================================
2027 bool SMESHGUI::automaticUpdate( SMESH::SMESH_Mesh_ptr theMesh,
2028                                 int* entities, bool* limitExceeded, int* hidden )
2029 {
2030   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2031   if ( !resMgr )
2032     return false;
2033
2034   bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update", false );
2035   long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2036   bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2037
2038   long requestedSize = theMesh->NbElements();
2039
2040   *entities = SMESH_Actor::eAllEntity;
2041   *hidden   = 0;
2042
2043   bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2044
2045   if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2046
2047   if ( incrementalLimit ) {
2048     long nbOdElems = theMesh->Nb0DElements();
2049     long nbEdges   = theMesh->NbEdges();
2050     long nbFaces   = theMesh->NbFaces();
2051     long nbVolumes = theMesh->NbVolumes();
2052     long nbBalls   = theMesh->NbBalls();
2053     long total     = 0;
2054
2055     if ( nbOdElems > 0 ) {
2056       if ( total + nbOdElems > updateLimit ) {
2057         *entities = *entities & ~SMESH_Actor::e0DElements;
2058         *hidden = *hidden | SMESH_Actor::e0DElements;
2059       }
2060       else
2061         exceeded = false;
2062     }
2063     total += nbOdElems;
2064
2065     if ( nbEdges > 0 ) {
2066       if ( total + nbEdges > updateLimit ) {
2067         *entities = *entities & ~SMESH_Actor::eEdges;
2068         *hidden = *hidden | SMESH_Actor::eEdges;
2069       }
2070       else
2071         exceeded = false;
2072     }
2073     total += nbEdges;
2074
2075     if ( nbFaces > 0 ) {
2076       if ( total + nbFaces > updateLimit ) {
2077         *entities = *entities & ~SMESH_Actor::eFaces;
2078         *hidden = *hidden | SMESH_Actor::eFaces;
2079       }
2080       else
2081         exceeded = false;
2082     }
2083     total += nbFaces;
2084
2085     if ( nbVolumes > 0 ) {
2086       if ( total + nbVolumes > updateLimit ) {
2087         *entities = *entities & ~SMESH_Actor::eVolumes;
2088         *hidden = *hidden | SMESH_Actor::eVolumes;
2089       }
2090       else
2091         exceeded = false;
2092     }
2093     total += nbVolumes;
2094
2095     if ( nbBalls > 0 ) {
2096       if ( total + nbBalls > updateLimit ) {
2097         *entities = *entities & ~SMESH_Actor::eBallElem;
2098         *hidden = *hidden | SMESH_Actor::eBallElem;
2099       }
2100       else
2101         exceeded = false;
2102     }
2103     total += nbBalls;
2104   }
2105
2106   return autoUpdate && !exceeded;
2107 }
2108
2109 //=============================================================================
2110 /*!
2111  *
2112  */
2113 //=============================================================================
2114 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2115 {
2116   return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2117 }
2118
2119 //=============================================================================
2120 /*!
2121  *
2122  */
2123 //=============================================================================
2124 SMESHGUI* SMESHGUI::GetSMESHGUI()
2125 {
2126   SMESHGUI* smeshMod = 0;
2127   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2128   if ( app )
2129   {
2130     CAM_Module* module = app->module( "Mesh" );
2131     smeshMod = dynamic_cast<SMESHGUI*>( module );
2132   }
2133
2134   if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2135   {
2136     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2137     if ( study )
2138     {
2139       _PTR(Study) aStudy = study->studyDS();
2140       if ( aStudy )
2141         GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2142     }
2143   }
2144
2145   return smeshMod;
2146 }
2147
2148 extern "C"
2149 {
2150   Standard_EXPORT SMESHGUI* GetComponentGUI()
2151   {
2152     return SMESHGUI::GetSMESHGUI();
2153   }
2154 }
2155
2156 //=============================================================================
2157 /*!
2158  *
2159  */
2160 //=============================================================================
2161 void SMESHGUI::SetState(int aState)
2162 {
2163   myState = aState;
2164 }
2165
2166 //=============================================================================
2167 /*!
2168  *
2169  */
2170 //=============================================================================
2171 void SMESHGUI::ResetState()
2172 {
2173   myState = -1;
2174 }
2175
2176 //=============================================================================
2177 /*!
2178  *
2179  */
2180 //=============================================================================
2181 void SMESHGUI::EmitSignalDeactivateDialog()
2182 {
2183   emit SignalDeactivateActiveDialog();
2184 }
2185
2186 //=============================================================================
2187 /*!
2188  *
2189  */
2190 //=============================================================================
2191 void SMESHGUI::EmitSignalStudyFrameChanged()
2192 {
2193   emit SignalStudyFrameChanged();
2194 }
2195
2196 //=============================================================================
2197 /*!
2198  *
2199  */
2200 //=============================================================================
2201 void SMESHGUI::EmitSignalCloseAllDialogs()
2202 {
2203   emit SignalCloseAllDialogs();
2204 }
2205
2206 //=============================================================================
2207 /*!
2208  *
2209  */
2210 //=============================================================================
2211 void SMESHGUI::EmitSignalVisibilityChanged()
2212 {
2213   emit SignalVisibilityChanged();
2214 }
2215
2216 //=============================================================================
2217 /*!
2218  *
2219  */
2220 //=============================================================================
2221 QDialog *SMESHGUI::GetActiveDialogBox()
2222 {
2223   return myActiveDialogBox;
2224 }
2225
2226 //=============================================================================
2227 /*!
2228  *
2229  */
2230 //=============================================================================
2231 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2232 {
2233   myActiveDialogBox = (QDialog *) aDlg;
2234   return;
2235 }
2236
2237 //=============================================================================
2238 /*!
2239  *
2240  */
2241 //=============================================================================
2242 SUIT_Desktop* SMESHGUI::desktop()
2243 {
2244   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2245   if( app )
2246     return app->desktop();
2247   else
2248     return 0;
2249 }
2250
2251 //=============================================================================
2252 /*!
2253  *
2254  */
2255 //=============================================================================
2256 SalomeApp_Study* SMESHGUI::activeStudy()
2257 {
2258   SUIT_Application* app = SUIT_Session::session()->activeApplication();
2259   if( app )
2260     return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2261   else
2262     return NULL;
2263 }
2264
2265 //=============================================================================
2266 /*!
2267  *
2268  */
2269 //=============================================================================
2270 void SMESHGUI::Modified( bool theIsUpdateActions )
2271 {
2272   if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2273     if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2274       appStudy->Modified();
2275       if( theIsUpdateActions )
2276         app->updateActions();
2277     }
2278   }
2279 }
2280
2281 //=============================================================================
2282 /*!
2283  *
2284  */
2285 //=============================================================================
2286 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2287 {
2288   /* Here the position is on the bottom right corner - 10 */
2289   // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2290   aDlg->adjustSize();
2291   SUIT_Desktop *PP = desktop();
2292   x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2293   y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2294   return true;
2295 }
2296
2297 //=============================================================================
2298 /*!
2299  *
2300  */
2301 //=============================================================================
2302 static int isStudyLocked(_PTR(Study) theStudy){
2303   return theStudy->GetProperties()->IsLocked();
2304 }
2305
2306 static bool checkLock(_PTR(Study) theStudy) {
2307   if (isStudyLocked(theStudy)) {
2308     SUIT_MessageBox::warning( SMESHGUI::desktop(),
2309                               QObject::tr("WRN_WARNING"),
2310                               QObject::tr("WRN_STUDY_LOCKED") );
2311     return true;
2312   }
2313   return false;
2314 }
2315
2316 //=======================================================================
2317 //function : CheckActiveStudyLocked
2318 //purpose  :
2319 //=======================================================================
2320
2321 bool SMESHGUI::isActiveStudyLocked()
2322 {
2323   _PTR(Study) aStudy = activeStudy()->studyDS();
2324   return checkLock( aStudy );
2325 }
2326
2327 //=============================================================================
2328 /*!
2329  *
2330  */
2331 //=============================================================================
2332 bool SMESHGUI::OnGUIEvent( int theCommandID )
2333 {
2334   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2335   if( !anApp )
2336     return false;
2337
2338   _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2339   SUIT_ResourceMgr* mgr = resourceMgr();
2340   if( !mgr )
2341     return false;
2342
2343   if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2344     GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2345   }
2346
2347   SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2348   SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2349
2350   //QAction* act = action( theCommandID );
2351
2352   switch (theCommandID) {
2353   case 33:                                      // DELETE
2354     if(checkLock(aStudy)) break;
2355     OnEditDelete();
2356     break;
2357
2358   case 116:
2359   case 115:
2360   case 117:
2361   case 118:
2362   case 113:
2363   case 112:
2364   case 111:                                     // IMPORT
2365     {
2366       if(checkLock(aStudy)) break;
2367       ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2368       break;
2369     }
2370
2371   case 150:    //MED FILE INFORMATION
2372     {
2373       SALOME_ListIO selected;
2374       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2375       if( aSel )
2376         aSel->selectedObjects( selected );
2377       if( selected.Extent() )
2378       {
2379         Handle(SALOME_InteractiveObject) anIObject = selected.First();
2380         SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2381         if ( !aMesh->_is_nil() )
2382         {
2383           SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2384           dlg.exec();
2385         }
2386       }
2387       break;
2388     }
2389
2390   case 122:                                     // EXPORT MED
2391   case 121:
2392   case 123:
2393   case 124:
2394   case 125:
2395   case 126:
2396   case 140:
2397   case 141:
2398   case 142:
2399   case 143:
2400   case 144:
2401   case 145:
2402   case 146:
2403   case 147:
2404     {
2405       ::ExportMeshToFile(theCommandID);
2406       break;
2407     }
2408
2409   case 200:                                     // SCALAR BAR
2410     {
2411       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2412       SALOME_ListIO selected;
2413       if( aSel )
2414         aSel->selectedObjects( selected );
2415
2416       if( selected.Extent() ) {
2417         Handle(SALOME_InteractiveObject) anIO = selected.First();
2418         if( anIO->hasEntry() ) {
2419           if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2420             anActor->SetControlMode( SMESH_Actor::eNone );
2421 #ifndef DISABLE_PLOT2DVIEWER
2422             SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2423 #endif
2424           }
2425         }
2426       }
2427       break;
2428     }
2429   case 201:
2430     {
2431       SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2432       break;
2433     }
2434   case 2021:
2435     {
2436       // dump control distribution data to the text file
2437       ::SaveDistribution();
2438       break;
2439     }
2440
2441   case 2022:
2442     {
2443       // show/ distribution
2444       ::ShowDistribution();
2445       break;
2446     }
2447
2448 #ifndef DISABLE_PLOT2DVIEWER
2449   case 2023:
2450     {
2451       // plot distribution
2452       ::PlotDistribution();
2453       break;
2454     }
2455 #endif
2456
2457     // Auto-color
2458   case 1136:
2459     ::AutoColor();
2460   break;
2461
2462   case 1137:
2463     ::DisableAutoColor();
2464   break;
2465
2466   case 1134: // Clipping
2467   case 1133: // Tranparency
2468   case 1132: // Display preferences (colors, shrink size, line width, ...)
2469
2470     // Display Mode
2471   case 215: // Nodes
2472   case 213: // Nodes
2473   case 212: // Nodes
2474   case 211: // Nodes
2475     ::SetDisplayMode(theCommandID, myMarkerMap);
2476   break;
2477
2478   //2D quadratic representation
2479   case 231:
2480   case 232:
2481     ::SetDisplayMode(theCommandID, myMarkerMap);
2482   break;
2483
2484   // Display Entity
2485   case 216: // 0D elements
2486   case 217: // Edges
2487   case 218: // Faces
2488   case 219: // Volumes
2489   case 220: // All Entity
2490   case 222: // Balls
2491     ::SetDisplayEntity(theCommandID);
2492   break;
2493
2494   case 221: // Orientation of faces
2495     {
2496       LightApp_SelectionMgr* mgr = selectionMgr();
2497       SALOME_ListIO selected; mgr->selectedObjects( selected );
2498
2499       SALOME_ListIteratorOfListIO it(selected);
2500       for( ; it.More(); it.Next()) {
2501         Handle(SALOME_InteractiveObject) anIObject = it.Value();
2502         if(anIObject->hasEntry()) {
2503           if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2504             anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2505           }
2506         }
2507       }
2508       break;
2509     }
2510
2511   case 214:                                     // UPDATE
2512     {
2513       if(checkLock(aStudy)) break;
2514       SUIT_OverrideCursor wc;
2515       try {
2516 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2517         OCC_CATCH_SIGNALS;
2518 #endif
2519         SMESH::UpdateView();
2520       }
2521       catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2522         SMESH::OnVisuException();
2523       }
2524       catch (...) { // PAL16774 (Crash after display of many groups)
2525         SMESH::OnVisuException();
2526       }
2527
2528       SALOME_ListIO l;
2529       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2530       aSel->selectedObjects( l );
2531       aSel->setSelectedObjects( l );
2532       break;
2533     }
2534
2535   case 300:                                     // ERASE
2536   case 301:                                     // DISPLAY
2537   case 302:                                     // DISPLAY ONLY
2538     {
2539       SMESH::EDisplaing anAction;
2540       switch (theCommandID) {
2541       case 300: anAction = SMESH::eErase; break;
2542       case 301: anAction = SMESH::eDisplay; break;
2543       case 302: anAction = SMESH::eDisplayOnly; break;
2544       }
2545
2546       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2547       SALOME_ListIO sel_objects, to_process;
2548       if (aSel)
2549         aSel->selectedObjects( sel_objects );
2550
2551       if( theCommandID==302 )
2552       {
2553         MESSAGE("anAction = SMESH::eDisplayOnly");
2554         startOperation( myEraseAll );
2555       }
2556
2557       extractContainers( sel_objects, to_process );
2558
2559       try {
2560 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2561         OCC_CATCH_SIGNALS;
2562 #endif
2563         if (vtkwnd) {
2564           SALOME_ListIteratorOfListIO It( to_process );
2565           for ( ; It.More(); It.Next()) {
2566             MESSAGE("---");
2567             Handle(SALOME_InteractiveObject) IOS = It.Value();
2568             if (IOS->hasEntry()) {
2569               MESSAGE("---");
2570               if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2571                 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2572                 break; // PAL16774 (Crash after display of many groups)
2573               }
2574               if (anAction == SMESH::eDisplayOnly)
2575               {
2576                 MESSAGE("anAction = SMESH::eDisplayOnly");
2577                 anAction = SMESH::eDisplay;
2578               }
2579             }
2580           }
2581         }
2582
2583         // PAL13338 + PAL15161 -->
2584         if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2585           MESSAGE("anAction = SMESH::eDisplayOnly");
2586           SMESH::UpdateView();
2587           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2588         }
2589         // PAL13338 + PAL15161 <--
2590       }
2591       catch (...) { // PAL16774 (Crash after display of many groups)
2592         SMESH::OnVisuException();
2593       }
2594
2595       if (anAction == SMESH::eErase) {
2596         MESSAGE("anAction == SMESH::eErase");
2597         SALOME_ListIO l1;
2598         aSel->setSelectedObjects( l1 );
2599       }
2600       else
2601         aSel->setSelectedObjects( to_process );
2602
2603       break;
2604     }
2605
2606   case 4000:                                    // NODES
2607     {
2608       if(checkLock(aStudy)) break;
2609
2610       if ( vtkwnd ) {
2611         EmitSignalDeactivateDialog();
2612
2613         ( new SMESHGUI_NodesDlg( this ) )->show();
2614       }
2615       else {
2616         SUIT_MessageBox::warning(desktop(),
2617                                  tr("SMESH_WRN_WARNING"),
2618                                  tr("SMESH_WRN_VIEWER_VTK"));
2619       }
2620       break;
2621     }
2622
2623   case 2151:  // FILTER
2624   {
2625     if ( vtkwnd )
2626     {
2627       EmitSignalDeactivateDialog();
2628       ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2629     }
2630     break;
2631   }
2632
2633   case 701: // COMPUTE MESH
2634   case 711: // PRECOMPUTE MESH
2635   case 712: // EVALUATE MESH
2636   case 713: // MESH ORDER
2637   case 702: // Create mesh
2638   case 703: // Create sub-mesh
2639   case 704: // Edit mesh/sub-mesh
2640     startOperation( theCommandID );
2641     break;
2642   case 705: // copy mesh
2643     {
2644       if (checkLock(aStudy)) break;
2645       EmitSignalDeactivateDialog();
2646       ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2647     }
2648     break;
2649   case 710: // Build compound mesh
2650     {
2651       if (checkLock(aStudy)) break;
2652       EmitSignalDeactivateDialog();
2653       ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2654     }
2655     break;
2656
2657   case 407: // DIAGONAL INVERSION
2658   case 408: // Delete diagonal
2659     {
2660       if ( !vtkwnd )
2661       {
2662         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2663                                   tr( "NOT_A_VTK_VIEWER" ) );
2664         break;
2665       }
2666
2667       if ( checkLock( aStudy ) )
2668         break;
2669
2670       /*Standard_Boolean aRes;
2671       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2672       if ( aMesh->_is_nil() )
2673       {
2674         SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2675           tr( "SMESH_BAD_SELECTION" ) );
2676         break;
2677       }
2678       */
2679       EmitSignalDeactivateDialog();
2680       if ( theCommandID == 407 )
2681         ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2682       else
2683         ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2684       break;
2685     }
2686   case 409: // Change orientation
2687   case 410: // Union of triangles
2688   case 411: // Cutting of quadrangles
2689   case 419: // Splitting volumes into tetrahedra
2690     {
2691       if ( !vtkwnd )
2692       {
2693         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2694                                   tr( "NOT_A_VTK_VIEWER" ) );
2695         break;
2696       }
2697
2698       if ( checkLock( aStudy ) )
2699         break;
2700
2701       EmitSignalDeactivateDialog();
2702       SMESHGUI_MultiEditDlg* aDlg = NULL;
2703       if ( theCommandID == 409 )
2704         aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2705       else if ( theCommandID == 410 )
2706         aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2707       else if ( theCommandID == 419 )
2708         aDlg = new SMESHGUI_SplitVolumesDlg(this);
2709       else
2710         aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2711
2712       aDlg->show();
2713       break;
2714     }
2715   case 412: // Smoothing
2716     {
2717       if(checkLock(aStudy)) break;
2718       if( vtkwnd ) {
2719         EmitSignalDeactivateDialog();
2720         ( new SMESHGUI_SmoothingDlg( this ) )->show();
2721       }
2722       else {
2723         SUIT_MessageBox::warning(desktop(),
2724                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2725       }
2726       break;
2727     }
2728   case 413: // Extrusion
2729     {
2730       if (checkLock(aStudy)) break;
2731       if (vtkwnd) {
2732         EmitSignalDeactivateDialog();
2733         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2734       } else {
2735         SUIT_MessageBox::warning(desktop(),
2736                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2737       }
2738       break;
2739     }
2740   case 414: // Revolution
2741     {
2742       if(checkLock(aStudy)) break;
2743       if( vtkwnd ) {
2744         EmitSignalDeactivateDialog();
2745         ( new SMESHGUI_RevolutionDlg( this ) )->show();
2746       }
2747       else {
2748         SUIT_MessageBox::warning(desktop(),
2749                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2750       }
2751       break;
2752     }
2753   case 415: // Pattern mapping
2754     {
2755       if ( checkLock( aStudy ) )
2756         break;
2757       if ( vtkwnd )
2758       {
2759         EmitSignalDeactivateDialog();
2760         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2761       }
2762       else {
2763         SUIT_MessageBox::warning(desktop(),
2764                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2765       }
2766       break;
2767     }
2768   case 416: // Extrusion along a path
2769     {
2770       if (checkLock(aStudy)) break;
2771       if (vtkwnd) {
2772         EmitSignalDeactivateDialog();
2773         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2774       } else {
2775         SUIT_MessageBox::warning(desktop(),
2776                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2777       }
2778       break;
2779     }
2780   case 417: // Convert mesh to quadratic
2781   case 418: // create 2D mesh from 3D
2782   case 420: // Reorient faces
2783   case 806: // CREATE GEO GROUP
2784     {
2785       startOperation( theCommandID );
2786       break;
2787     }
2788   case 801:                                     // CREATE GROUP
2789     {
2790       if ( !vtkwnd )
2791       {
2792         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2793                                   tr( "NOT_A_VTK_VIEWER" ) );
2794         break;
2795       }
2796
2797       if(checkLock(aStudy)) break;
2798       EmitSignalDeactivateDialog();
2799       SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2800
2801       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2802       SALOME_ListIO selected;
2803       if( aSel )
2804         aSel->selectedObjects( selected );
2805
2806       int nbSel = selected.Extent();
2807       if (nbSel == 1) {
2808         // check if mesh is selected
2809         aMesh = SMESH::GetMeshByIO( selected.First() );
2810       }
2811       SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2812       aDlg->show();
2813       break;
2814     }
2815
2816   case 802:                                     // CONSTRUCT GROUP
2817     {
2818       if ( !vtkwnd )
2819       {
2820         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2821                                   tr( "NOT_A_VTK_VIEWER" ) );
2822         break;
2823       }
2824
2825       if(checkLock(aStudy)) break;
2826       EmitSignalDeactivateDialog();
2827
2828       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2829       SALOME_ListIO selected;
2830       if( aSel )
2831         aSel->selectedObjects( selected );
2832
2833       int nbSel = selected.Extent();
2834       if (nbSel == 1) {
2835         // check if submesh is selected
2836         Handle(SALOME_InteractiveObject) IObject = selected.First();
2837         if (IObject->hasEntry()) {
2838           _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2839           if( aSObj ) {
2840             SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2841             if (!aSubMesh->_is_nil()) {
2842               try {
2843                 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2844                 // get submesh elements list by types
2845                 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2846                 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2847                 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2848                 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2849                 // create group for each type o elements
2850                 QString aName = IObject->getName();
2851                 QStringList anEntryList;
2852                 if (aNodes->length() > 0) {
2853                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2854                   aGroup->Add(aNodes.inout());
2855                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2856                     anEntryList.append( aSObject->GetID().c_str() );
2857                 }
2858                 if (aEdges->length() > 0) {
2859                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2860                   aGroup->Add(aEdges.inout());
2861                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2862                     anEntryList.append( aSObject->GetID().c_str() );
2863                 }
2864                 if (aFaces->length() > 0) {
2865                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2866                   aGroup->Add(aFaces.inout());
2867                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2868                     anEntryList.append( aSObject->GetID().c_str() );
2869                 }
2870                 if (aVolumes->length() > 0) {
2871                   SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2872                   aGroup->Add(aVolumes.inout());
2873                   if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2874                     anEntryList.append( aSObject->GetID().c_str() );
2875                 }
2876                 updateObjBrowser();
2877                 anApp->browseObjects( anEntryList );
2878               }
2879               catch(const SALOME::SALOME_Exception & S_ex){
2880                 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2881               }
2882             }
2883           }
2884         }
2885       }
2886       else if(nbSel==0) {
2887         SUIT_MessageBox::warning(desktop(),
2888                                  tr("SMESH_WRN_WARNING"),
2889                                  tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2890       }
2891       break;
2892     }
2893
2894   case 803:                                     // EDIT GROUP
2895     {
2896       if ( !vtkwnd )
2897       {
2898         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2899                                   tr( "NOT_A_VTK_VIEWER" ) );
2900         break;
2901       }
2902
2903       if(checkLock(aStudy)) break;
2904       EmitSignalDeactivateDialog();
2905
2906       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2907       SALOME_ListIO selected;
2908       if( aSel )
2909         aSel->selectedObjects( selected );
2910
2911       SALOME_ListIteratorOfListIO It (selected);
2912       int nbSelectedGroups = 0;
2913       for ( ; It.More(); It.Next() )
2914       {
2915         SMESH::SMESH_GroupBase_var aGroup =
2916           SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2917         if (!aGroup->_is_nil()) {
2918           nbSelectedGroups++;
2919           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2920           aDlg->show();
2921         }
2922       }
2923       if (nbSelectedGroups == 0)
2924         {
2925           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2926           aDlg->show();
2927         }
2928       break;
2929     }
2930
2931   case 804:                                     // Add elements to group
2932     {
2933       if(checkLock(aStudy)) break;
2934       if (myState == 800) {
2935         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2936         if (aDlg) aDlg->onAdd();
2937       }
2938       break;
2939     }
2940
2941   case 805:                                     // Remove elements from group
2942     {
2943       if(checkLock(aStudy)) break;
2944       if (myState == 800) {
2945         SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2946         if (aDlg) aDlg->onRemove();
2947       }
2948       break;
2949     }
2950
2951   case 815:                                     // Edit GEOM GROUP as standalone
2952     {
2953       if ( !vtkwnd )
2954       {
2955         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2956                                   tr( "NOT_A_VTK_VIEWER" ) );
2957         break;
2958       }
2959
2960       if(checkLock(aStudy)) break;
2961       EmitSignalDeactivateDialog();
2962
2963       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2964       SALOME_ListIO selected;
2965       if( aSel )
2966         aSel->selectedObjects( selected );
2967
2968       SALOME_ListIteratorOfListIO It (selected);
2969       for ( ; It.More(); It.Next() )
2970       {
2971         SMESH::SMESH_GroupOnGeom_var aGroup =
2972           SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2973         if (!aGroup->_is_nil()) {
2974           SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2975           aDlg->show();
2976         }
2977         else
2978         {
2979           SMESH::SMESH_GroupOnFilter_var aGroup =
2980             SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2981           if (!aGroup->_is_nil()) {
2982             SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2983             aDlg->show();
2984           }
2985         }
2986       }
2987       break;
2988     }
2989
2990     case 810: // Union Groups
2991     case 811: // Intersect groups
2992     case 812: // Cut groups
2993     {
2994       if ( !vtkwnd )
2995       {
2996         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2997                                   tr( "NOT_A_VTK_VIEWER" ) );
2998         break;
2999       }
3000
3001       if ( checkLock( aStudy ) )
3002         break;
3003
3004       EmitSignalDeactivateDialog();
3005
3006       SMESHGUI_GroupOpDlg* aDlg = 0;
3007       if ( theCommandID == 810 )
3008         aDlg = new SMESHGUI_UnionGroupsDlg( this );
3009       else if ( theCommandID == 811 )
3010         aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3011       else
3012         aDlg = new SMESHGUI_CutGroupsDlg( this );
3013
3014       aDlg->show();
3015
3016       break;
3017     }
3018
3019     case 814: // Create groups of entities from existing groups of superior dimensions
3020     {
3021       if ( checkLock( aStudy ) )
3022         break;
3023
3024       EmitSignalDeactivateDialog();
3025       SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3026       aDlg->show();
3027
3028       break;
3029     }
3030
3031     case 813: // Delete groups with their contents
3032     {
3033       if ( !vtkwnd )
3034       {
3035         SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3036                                   tr( "NOT_A_VTK_VIEWER" ) );
3037         break;
3038       }
3039
3040       if ( checkLock( aStudy ) )
3041         break;
3042
3043       EmitSignalDeactivateDialog();
3044
3045       ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3046       break;
3047     }
3048
3049   case 900:                                     // MESH INFOS
3050   case 903:                                     // WHAT IS
3051     {
3052       int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3053       EmitSignalDeactivateDialog();
3054       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3055       SALOME_ListIO selected;
3056       if( aSel )
3057         aSel->selectedObjects( selected );
3058
3059       if ( selected.Extent() > 1 ) { // a dlg for each IO
3060         SALOME_ListIteratorOfListIO It( selected );
3061         for ( ; It.More(); It.Next() ) {
3062           SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3063           dlg->showInfo( It.Value() );
3064           dlg->show();
3065         }
3066       }
3067       else {
3068         SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3069         dlg->show();
3070       }
3071       break;
3072     }
3073
3074   case 904:                                     // FIND ELEM
3075     {
3076       startOperation( theCommandID );
3077       break;
3078     }
3079
3080   case 1100:                                    // EDIT HYPOTHESIS
3081     {
3082       if(checkLock(aStudy)) break;
3083
3084       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3085       SALOME_ListIO selected;
3086       if( aSel )
3087         aSel->selectedObjects( selected );
3088
3089       int nbSel = selected.Extent();
3090
3091       if (nbSel == 1) {
3092         Handle(SALOME_InteractiveObject) anIObject = selected.First();
3093         SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3094
3095         /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
3096         /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
3097         /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
3098         if ( !aHypothesis->_is_nil() )
3099         {
3100           // BUG 0020378
3101           //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3102           SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
3103           if (aCreator) {
3104             aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3105           }
3106           else
3107           {
3108             // report error
3109           }
3110         }
3111       }
3112       break;
3113     }
3114   case 1102:                                    // REMOVE HYPOTHESIS / ALGORITHMS
3115     {
3116       if(checkLock(aStudy)) break;
3117       SUIT_OverrideCursor wc;
3118
3119       LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3120       SALOME_ListIO selected;
3121       if( aSel )
3122         aSel->selectedObjects( selected, QString::null, false );
3123
3124       SALOME_ListIteratorOfListIO It(selected);
3125       for (int i = 0; It.More(); It.Next(), i++) {
3126         Handle(SALOME_InteractiveObject) IObject = It.Value();
3127         SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3128       }
3129       SALOME_ListIO l1;
3130       aSel->setSelectedObjects( l1 );
3131       updateObjBrowser();
3132       break;
3133     }
3134
3135   case 4008:                                    // BALL
3136   case 4009:                                    // ELEM0D
3137   case 4010:                                    // EDGE
3138   case 4021:                                    // TRIANGLE
3139   case 4022:                                    // QUAD
3140   case 4023:                                    // POLYGON
3141   case 4031:                                    // TETRA
3142   case 4032:                                    // HEXA
3143   case 4133:                                    // PENTA
3144   case 4134:                                    // PYRAMID
3145   case 4135:                                    // OCTA12
3146     {
3147       if(checkLock(aStudy)) break;
3148       if ( vtkwnd ) {
3149         EmitSignalDeactivateDialog();
3150         SMDSAbs_EntityType type = SMDSEntity_Edge;
3151         switch (theCommandID) {
3152         case 4008: type = SMDSEntity_Ball;            break;
3153         case 4009: type = SMDSEntity_0D;              break;
3154         case 4021: type = SMDSEntity_Triangle;        break;
3155         case 4022: type = SMDSEntity_Quadrangle;      break;
3156         case 4031: type = SMDSEntity_Tetra;           break;
3157         case 4023: type = SMDSEntity_Polygon;         break;
3158         case 4032: type = SMDSEntity_Hexa;            break;
3159         case 4133: type = SMDSEntity_Penta;           break;
3160         case 4134: type = SMDSEntity_Pyramid;         break;
3161         case 4135: type = SMDSEntity_Hexagonal_Prism; break;
3162         default:;
3163         }
3164         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3165       }
3166       else {
3167         SUIT_MessageBox::warning(desktop(),
3168                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3169       }
3170       break;
3171     }
3172   case 4033:                                    // POLYHEDRON
3173     {
3174       if(checkLock(aStudy)) break;
3175       if ( vtkwnd ) {
3176         EmitSignalDeactivateDialog();
3177         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3178       }
3179       else {
3180         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3181                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3182       }
3183       break;
3184     }
3185   case 4034:     // QUADRATIC EDGE
3186   case 4035:     // QUADRATIC TRIANGLE
3187   case 4036:     // QUADRATIC QUADRANGLE
3188   case 4136:     // BIQUADRATIC QUADRANGLE
3189   case 4137:     // BIQUADRATIC TRIANGLE
3190   case 4037:     // QUADRATIC TETRAHEDRON
3191   case 4038:     // QUADRATIC PYRAMID
3192   case 4039:     // QUADRATIC PENTAHEDRON
3193   case 4040:     // QUADRATIC HEXAHEDRON
3194   case 4140:     // TRIQUADRATIC HEXAHEDRON
3195     {
3196       if(checkLock(aStudy)) break;
3197       if ( vtkwnd ) {
3198         EmitSignalDeactivateDialog();
3199         SMDSAbs_EntityType type = SMDSEntity_Last;
3200
3201         switch (theCommandID) {
3202         case 4034: type = SMDSEntity_Quad_Edge; break;
3203         case 4035: type = SMDSEntity_Quad_Triangle; break;
3204         case 4036: type = SMDSEntity_Quad_Quadrangle; break;
3205         case 4136: type = SMDSEntity_BiQuad_Quadrangle; break;
3206         case 4137: type = SMDSEntity_BiQuad_Triangle; break;
3207         case 4037: type = SMDSEntity_Quad_Tetra; break;
3208         case 4038: type = SMDSEntity_Quad_Pyramid; break;
3209         case 4039: type = SMDSEntity_Quad_Penta; break;
3210         case 4040: type = SMDSEntity_Quad_Hexa; break;
3211         case 4140: type = SMDSEntity_TriQuad_Hexa; break;
3212         default: break;
3213         }
3214         if ( type != SMDSEntity_Last )
3215           ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3216       }
3217       else {
3218         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3219                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3220       }
3221       break;
3222     }
3223   case 4041:                                    // REMOVES NODES
3224     {
3225       if(checkLock(aStudy)) break;
3226       if ( vtkwnd ) {
3227         EmitSignalDeactivateDialog();
3228         ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3229       }
3230       else {
3231         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3232                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3233       }
3234       break;
3235     }
3236   case 4042:                                    // REMOVES ELEMENTS
3237     {
3238       if(checkLock(aStudy)) break;
3239       if( vtkwnd ) {
3240         EmitSignalDeactivateDialog();
3241         ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3242       }
3243       else
3244         {
3245           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3246                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3247         }
3248       break;
3249     }
3250   case 4043: {                                // CLEAR_MESH
3251
3252     if(checkLock(aStudy)) break;
3253
3254     SALOME_ListIO selected;
3255     if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3256       aSel->selectedObjects( selected );
3257
3258     SUIT_OverrideCursor wc;
3259     SALOME_ListIteratorOfListIO It (selected);
3260     for ( ; It.More(); It.Next() )
3261     {
3262       Handle(SALOME_InteractiveObject) IOS = It.Value();
3263       SMESH::SMESH_Mesh_var aMesh =
3264         SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3265       if ( aMesh->_is_nil()) continue;
3266       try {
3267         SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3268         aMesh->Clear();
3269         _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3270         SMESH::ModifiedMesh( aMeshSObj, false, true);
3271         // hide groups and submeshes
3272         _PTR(ChildIterator) anIter =
3273           SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3274         for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3275         {
3276           _PTR(SObject) so = anIter->Value();
3277           SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3278         }
3279       }
3280       catch (const SALOME::SALOME_Exception& S_ex){
3281         wc.suspend();
3282         SalomeApp_Tools::QtCatchCorbaException(S_ex);
3283         wc.resume();
3284       }
3285     }
3286     SMESH::UpdateView();
3287     updateObjBrowser();
3288     break;
3289   }
3290   case 4044:                                     // REMOVE ORPHAN NODES
3291     {
3292       if(checkLock(aStudy)) break;
3293       SALOME_ListIO selected;
3294       if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3295         aSel->selectedObjects( selected );
3296       if ( selected.Extent() == 1 ) {
3297         Handle(SALOME_InteractiveObject) anIO = selected.First();
3298         SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3299         if ( !aMesh->_is_nil() ) {
3300           bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3301                                                     tr( "SMESH_WARNING" ),
3302                                                     tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3303                                                     SUIT_MessageBox::Yes |
3304                                                     SUIT_MessageBox::No,
3305                                                     SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3306           if( confirm ) {
3307             try {
3308               SUIT_OverrideCursor wc;
3309               SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3310               int removed = aMeshEditor->RemoveOrphanNodes();
3311               SUIT_MessageBox::information(SMESHGUI::desktop(),
3312                                            tr("SMESH_INFORMATION"),
3313                                            tr("NB_NODES_REMOVED").arg(removed));
3314               if ( removed > 0 ) {
3315                 SMESH::UpdateView();
3316                 SMESHGUI::Modified();
3317               }
3318             }
3319             catch (const SALOME::SALOME_Exception& S_ex) {
3320               SalomeApp_Tools::QtCatchCorbaException(S_ex);
3321             }
3322             catch (...) {
3323             }
3324           }
3325         }
3326       }
3327       break;
3328     }
3329   case 4051:                                    // RENUMBERING NODES
3330     {
3331       if(checkLock(aStudy)) break;
3332       if( vtkwnd ) {
3333         EmitSignalDeactivateDialog();
3334         ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3335       }
3336       else
3337         {
3338           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3339                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3340         }
3341       break;
3342     }
3343   case 4052:                                    // RENUMBERING ELEMENTS
3344     {
3345       if(checkLock(aStudy)) break;
3346       if ( vtkwnd ) {
3347         EmitSignalDeactivateDialog();
3348         ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3349       }
3350       else
3351         {
3352           SUIT_MessageBox::warning(SMESHGUI::desktop(),
3353                                    tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3354         }
3355       break;
3356     }
3357   case 4061:                                   // TRANSLATION
3358     {
3359       if(checkLock(aStudy)) break;
3360       if ( vtkwnd ) {
3361         EmitSignalDeactivateDialog();
3362         ( new SMESHGUI_TranslationDlg( this ) )->show();
3363       }
3364       else {
3365         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3366                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3367       }
3368       break;
3369     }
3370   case 4062:                                   // ROTATION
3371     {
3372       if(checkLock(aStudy)) break;
3373       if( vtkwnd ) {
3374         EmitSignalDeactivateDialog();
3375         ( new SMESHGUI_RotationDlg( this ) )->show();
3376       }
3377       else {
3378         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3379                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3380       }
3381       break;
3382     }
3383   case 4063:                                   // SYMMETRY
3384     {
3385       if(checkLock(aStudy)) break;
3386       if(vtkwnd) {
3387         EmitSignalDeactivateDialog();
3388         ( new SMESHGUI_SymmetryDlg( this ) )->show();
3389       }
3390       else {
3391         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3392                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3393       }
3394       break;
3395     }
3396   case 4064:                                   // SEWING
3397     {
3398       if(checkLock(aStudy)) break;
3399       if(vtkwnd) {
3400         EmitSignalDeactivateDialog();
3401         ( new SMESHGUI_SewingDlg( this ) )->show();
3402       }
3403       else {
3404         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3405                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3406       }
3407       break;
3408     }
3409   case 4065:                                   // MERGE NODES
3410     {
3411       if(checkLock(aStudy)) break;
3412       if(vtkwnd) {
3413         EmitSignalDeactivateDialog();
3414         ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3415       }
3416       else {
3417         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3418                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3419       }
3420       break;
3421     }
3422   case 4066:                                   // MERGE EQUAL ELEMENTS
3423     {
3424       if (checkLock(aStudy)) break;
3425       if (vtkwnd) {
3426         EmitSignalDeactivateDialog();
3427         ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3428       } else {
3429         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3430                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3431       }
3432       break;
3433     }
3434
3435   case 4067: // MAKE MESH PASS THROUGH POINT
3436     startOperation( 4067 );
3437     break;
3438
3439   case 4068: // SCALE
3440     {
3441       if(checkLock(aStudy)) break;
3442       if ( vtkwnd ) {
3443         EmitSignalDeactivateDialog();
3444         ( new SMESHGUI_ScaleDlg( this ) )->show();
3445       }
3446       else {
3447         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3448                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449       }
3450       break;
3451     }
3452
3453   case 4069: // DUPLICATE NODES
3454     {
3455       if(checkLock(aStudy)) break;
3456       if ( vtkwnd ) {
3457         EmitSignalDeactivateDialog();
3458         ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3459       }
3460       else {
3461         SUIT_MessageBox::warning(SMESHGUI::desktop(),
3462                                  tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3463       }
3464       break;
3465     }
3466
3467   case 4070: // 0D_ON_ALL_NODES
3468     startOperation( 4070 );
3469     break;
3470
3471   case 5105: // Library of selection filters
3472   {
3473     static QList<int> aTypes;
3474     if ( aTypes.isEmpty() )
3475     {
3476       aTypes.append( SMESH::NODE );
3477       aTypes.append( SMESH::EDGE );
3478       aTypes.append( SMESH::FACE );
3479       aTypes.append( SMESH::VOLUME );
3480     }
3481     if (!myFilterLibraryDlg)
3482       myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3483     else if (myFilterLibraryDlg->isHidden())
3484       myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3485     myFilterLibraryDlg->raise();
3486   }
3487   break;
3488
3489   case 6017:                                    // CONTROLS
3490   case 6016:
3491   case 6015:
3492   case 6014:
3493   case 6013:
3494   case 6012:
3495   case 6011:
3496   case 6001:
3497   case 6018:
3498   case 6019:
3499   case 6002:
3500   case 6003:
3501   case 6004:
3502   case 6005:
3503   case 6009:
3504   case 6021:
3505   case 6022:
3506   case 6023:
3507   case 6024:
3508   case 6025:
3509   case 6026:
3510   case 6027:
3511   case 6028:
3512   case 6029:
3513   case 6030:
3514   case 6031:
3515     if ( vtkwnd ) {
3516
3517       LightApp_SelectionMgr* mgr = selectionMgr();
3518       SALOME_ListIO selected; mgr->selectedObjects( selected );
3519
3520       if ( selected.Extent() == 1 && selected.First()->hasEnt