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