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