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