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