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