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