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