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