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