1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_Make2DFrom3DOp.h"
64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
65 #include "SMESHGUI_Measurements.h"
66 #include "SMESHGUI_MergeDlg.h"
67 #include "SMESHGUI_MeshInfo.h"
68 #include "SMESHGUI_MeshOp.h"
69 #include "SMESHGUI_MeshOrderOp.h"
70 #include "SMESHGUI_MeshPatternDlg.h"
71 #include "SMESHGUI_MeshUtils.h"
72 #include "SMESHGUI_MultiEditDlg.h"
73 #include "SMESHGUI_NodesDlg.h"
74 #include "SMESHGUI_OffsetDlg.h"
75 #include "SMESHGUI_Operations.h"
76 #include "SMESHGUI_PatternUtils.h"
77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
78 #include "SMESHGUI_PropertiesDlg.h"
79 #include "SMESHGUI_RemoveElementsDlg.h"
80 #include "SMESHGUI_RemoveNodesDlg.h"
81 #include "SMESHGUI_RenumberingDlg.h"
82 #include "SMESHGUI_ReorientFacesDlg.h"
83 #include "SMESHGUI_RevolutionDlg.h"
84 #include "SMESHGUI_RotationDlg.h"
85 #include "SMESHGUI_ScaleDlg.h"
86 #include "SMESHGUI_Selection.h"
87 #include "SMESHGUI_SewingDlg.h"
88 #include "SMESHGUI_SingleEditDlg.h"
89 #include "SMESHGUI_SmoothingDlg.h"
90 #include "SMESHGUI_SpinBox.h"
91 #include "SMESHGUI_SplitBiQuad.h"
92 #include "SMESHGUI_SymmetryDlg.h"
93 #include "SMESHGUI_TranslationDlg.h"
94 #include "SMESHGUI_TransparencyDlg.h"
95 #include "SMESHGUI_Utils.h"
96 #include "SMESHGUI_VTKUtils.h"
98 #include "SMESH_version.h"
100 #include "SMESH_ControlsDef.hxx"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_ScalarBarActor.h"
105 #include <SMESH_Comment.hxx>
106 #include "SMESH_TypeFilter.hxx"
108 // SALOME GUI includes
109 #include <LightApp_DataOwner.h>
110 #include <LightApp_NameDlg.h>
111 #include <LightApp_Preferences.h>
112 #include <LightApp_SelectionMgr.h>
113 #include <LightApp_UpdateFlags.h>
114 #include <QtxFontEdit.h>
115 #include <QtxPopupMgr.h>
116 #include <SALOME_ListIO.hxx>
117 #include <SUIT_Desktop.h>
118 #include <SUIT_FileDlg.h>
119 #include <SUIT_MessageBox.h>
120 #include <SUIT_OverrideCursor.h>
121 #include <SUIT_ResourceMgr.h>
122 #include <SUIT_Session.h>
123 #include <SVTK_Renderer.h>
124 #include <SVTK_ViewManager.h>
125 #include <SVTK_ViewModel.h>
126 #include <SVTK_ViewWindow.h>
127 #include <SalomeApp_Application.h>
128 #include <SalomeApp_CheckFileDlg.h>
129 #include <SalomeApp_DataObject.h>
130 #include <SalomeApp_Study.h>
131 #include <SalomeApp_Tools.h>
132 #include <VTKViewer_Algorithm.h>
134 #ifndef DISABLE_PLOT2DVIEWER
135 #include <SPlot2d_ViewModel.h>
136 #include <SPlot2d_Histogram.h>
140 #include <SALOMEconfig.h>
141 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
142 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
143 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
147 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
148 #include <QApplication>
150 #include <QDialogButtonBox>
154 #include <QTextStream>
158 #include <boost/shared_ptr.hpp>
161 #include <vtkCallbackCommand.h>
162 #include <vtkCamera.h>
163 #include <vtkLookupTable.h>
164 #include <vtkPlane.h>
165 #include <vtkRenderer.h>
167 // SALOME KERNEL includes
168 #include <SALOMEDSClient_ClientFactory.hxx>
169 #include <SALOMEDSClient_IParameters.hxx>
170 #include <SALOMEDSClient_SComponent.hxx>
171 #include <SALOMEDSClient_StudyBuilder.hxx>
172 #include <SALOMEDS_Study.hxx>
173 #include <SALOMEDS_SObject.hxx>
174 #include "utilities.h"
177 #include <Standard_ErrorHandler.hxx>
178 #include <NCollection_DataMap.hxx>
179 #include <NCollection_DoubleMap.hxx>
181 #include <Basics_Utils.hxx>
183 // Below macro, when uncommented, switches on simplified (more performant) algorithm
184 // of auto-color picking up
185 #define SIMPLE_AUTOCOLOR
190 //=============================================================
191 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
194 void ExportMeshToFile(int theCommandID);
196 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
198 void SetDisplayEntity(int theCommandID);
200 int ActionToControl( int theID, bool theReversed = false );
202 void Control( int theCommandID );
205 //================================================================================
207 * \brief Reads meshes from file
209 //================================================================================
211 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
215 std::string myExtension;
217 if ( theCommandID == SMESHOp::OpImportMED ||
218 theCommandID == SMESHOp::OpPopupImportMED ) {
219 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
220 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
222 else if ( theCommandID == SMESHOp::OpImportUNV ||
223 theCommandID == SMESHOp::OpPopupImportUNV ) {
224 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
226 else if ( theCommandID == SMESHOp::OpImportDAT ||
227 theCommandID == SMESHOp::OpPopupImportDAT ) {
228 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
230 else if ( theCommandID == SMESHOp::OpImportSTL ||
231 theCommandID == SMESHOp::OpPopupImportSTL ) {
232 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
234 else if ( theCommandID == SMESHOp::OpImportCGNS ||
235 theCommandID == SMESHOp::OpPopupImportCGNS ) {
236 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
238 else if ( theCommandID == SMESHOp::OpImportSAUV ||
239 theCommandID == SMESHOp::OpPopupImportSAUV ) {
240 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
241 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
243 else if ( theCommandID == SMESHOp::OpImportGMF ||
244 theCommandID == SMESHOp::OpPopupImportGMF ) {
245 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
246 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
249 QString anInitialPath = "";
250 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
251 anInitialPath = QDir::currentPath();
253 QStringList filenames;
254 bool toCreateGroups = true;
256 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
257 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
258 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
259 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
260 // fd->setNameFilters( filter );
261 // fd->SetChecked( true );
263 // filenames << fd->selectedFile();
264 // toCreateGroups = fd->IsChecked();
270 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
273 QObject::tr( "SMESH_IMPORT_MESH" ) );
275 if ( filenames.count() > 0 )
277 SUIT_OverrideCursor wc;
278 _PTR(Study) aStudy = SMESH::getStudy();
281 QStringList anEntryList;
282 bool isEmpty = false;
283 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
285 QString filename = *it;
286 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
288 switch ( theCommandID ) {
289 case SMESHOp::OpImportDAT:
290 case SMESHOp::OpPopupImportDAT:
292 // DAT format (currently unsupported)
293 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
294 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
297 case SMESHOp::OpImportUNV:
298 case SMESHOp::OpPopupImportUNV:
301 aMeshes->length( 1 );
302 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
303 if ( aMeshes[0]->_is_nil() )
304 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
305 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
308 case SMESHOp::OpImportMED:
309 case SMESHOp::OpPopupImportMED:
312 SMESH::DriverMED_ReadStatus res;
313 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
314 if ( res != SMESH::DRS_OK ) {
315 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
316 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
320 case SMESHOp::OpImportSTL:
321 case SMESHOp::OpPopupImportSTL:
324 aMeshes->length( 1 );
325 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
326 if ( aMeshes[0]->_is_nil() ) {
327 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
328 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
332 case SMESHOp::OpImportCGNS:
333 case SMESHOp::OpPopupImportCGNS:
336 SMESH::DriverMED_ReadStatus res;
337 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
338 if ( res != SMESH::DRS_OK ) {
339 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
340 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
344 case SMESHOp::OpImportSAUV:
345 case SMESHOp::OpPopupImportSAUV:
348 SMESH::DriverMED_ReadStatus res;
349 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
350 if ( res != SMESH::DRS_OK ) {
351 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
352 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
356 case SMESHOp::OpImportGMF:
357 case SMESHOp::OpPopupImportGMF:
360 SMESH::ComputeError_var res;
361 aMeshes->length( 1 );
362 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
365 if ( res->code != SMESH::DRS_OK ) {
366 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
367 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
368 if ( strlen( res->comment.in() ) > 0 ) {
369 errors.back() += ": ";
370 errors.back() += res->comment.in();
377 catch ( const SALOME::SALOME_Exception& S_ex ) {
378 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
379 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
382 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
384 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
386 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
387 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
388 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
389 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
390 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
392 anEntryList.append( aMeshSO->GetID().c_str() );
400 // update Object browser
401 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
403 // browse to the published meshes
404 if( LightApp_Application* anApp =
405 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
406 anApp->browseObjects( anEntryList );
408 // show Error message box if there were errors
409 if ( errors.count() > 0 ) {
410 SUIT_MessageBox::critical( SMESHGUI::desktop(),
411 QObject::tr( "SMESH_ERROR" ),
412 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
415 // show warning message box, if some imported mesh is empty
417 SUIT_MessageBox::warning( SMESHGUI::desktop(),
418 QObject::tr( "SMESH_WRN_WARNING" ),
419 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
424 //================================================================================
426 * \brief Export selected meshes or groups into a file
428 //================================================================================
430 void ExportMeshToFile( int theCommandID )
432 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
433 SALOME_ListIO selected;
435 aSel->selectedObjects( selected );
437 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
438 theCommandID == SMESHOp::OpPopupExportDAT );
439 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
440 theCommandID == SMESHOp::OpPopupExportMED );
441 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
442 theCommandID == SMESHOp::OpPopupExportUNV );
443 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
444 theCommandID == SMESHOp::OpPopupExportSTL );
445 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
446 theCommandID == SMESHOp::OpPopupExportCGNS );
447 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
448 theCommandID == SMESHOp::OpPopupExportSAUV );
449 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
450 theCommandID == SMESHOp::OpPopupExportGMF );
452 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
453 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
455 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
456 bool aCheckWarn = true;
458 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
459 // get mesh object from selection and check duplication of their names
460 bool hasDuplicatedMeshNames = false;
461 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
462 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
463 SALOME_ListIteratorOfListIO It( selected );
464 for( ; It.More(); It.Next() )
466 Handle(SALOME_InteractiveObject) anIObject = It.Value();
467 SMESH::SMESH_IDSource_var aMeshItem =
468 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
469 if ( aMeshItem->_is_nil() ) {
470 SUIT_MessageBox::warning( SMESHGUI::desktop(),
471 QObject::tr( "SMESH_WRN_WARNING" ),
472 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
475 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
476 if ( aCheckWarn && !aGroup->_is_nil() )
478 QMessageBox msgBox(SUIT_MessageBox::Warning,
479 QObject::tr("SMESH_WRN_WARNING"),
480 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
481 QMessageBox::StandardButton::NoButton,
482 SMESHGUI::desktop());
483 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
484 msgBox.addButton(QMessageBox::Ok);
485 msgBox.addButton(QMessageBox::Cancel);
486 msgBox.setDefaultButton(QMessageBox::Cancel);
487 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
488 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
489 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
490 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
491 if ( msgBox.exec() != QMessageBox::Ok )
494 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
495 resMgr->setValue( "SMESH", "show_warning", false);
498 QString aMeshName = anIObject->getName();
500 // check for name duplications
501 if ( !hasDuplicatedMeshNames )
502 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
503 if( aMeshName == (*aMeshIter).second ) {
504 hasDuplicatedMeshNames = true;
509 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
512 if( hasDuplicatedMeshNames && isMED ) {
513 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
514 QObject::tr("SMESH_WRN_WARNING"),
515 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
516 QObject::tr("SMESH_BUT_YES"),
517 QObject::tr("SMESH_BUT_NO"), 0, 1);
522 aMeshIter = aMeshList.begin();
523 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
524 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
525 QString aMeshName = (*aMeshIter).second;
527 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
529 // check for equal group names within each mesh
530 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
531 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
532 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
533 int aRet = SUIT_MessageBox::warning
534 (SMESHGUI::desktop(),
535 QObject::tr("SMESH_WRN_WARNING"),
536 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
537 QObject::tr("SMESH_BUT_YES"),
538 QObject::tr("SMESH_BUT_NO"), 0, 1);
545 // Warn the user about presence of not supported elements
547 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
551 notSupportedElemTypes.push_back( SMESH::Entity_0D );
552 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
557 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
562 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
563 notSupportedElemTypes.push_back( SMESH::Entity_0D );
564 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
569 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
570 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
571 notSupportedElemTypes.push_back( SMESH::Entity_0D );
572 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
577 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
582 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
583 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
584 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
585 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
586 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
587 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
588 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
589 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
594 notSupportedElemTypes.push_back( SMESH::Entity_0D );
595 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
598 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
599 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
600 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
601 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
602 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
603 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
605 if ( ! notSupportedElemTypes.empty() )
607 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
608 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
609 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
610 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
612 if ( !presentNotSupported.empty() )
615 const char* typeMsg[] = {
616 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
617 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
618 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
619 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
620 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
621 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
622 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
623 "SMESH_BIQUADRATIC_PENTAHEDRONS",
624 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
626 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
627 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
628 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
630 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
631 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
632 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
633 if ( iType != presentNotSupported.size() - 1 )
634 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
636 int aRet = SUIT_MessageBox::warning
637 (SMESHGUI::desktop(),
638 QObject::tr("SMESH_WRN_WARNING"),
639 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
640 QObject::tr("SMESH_BUT_YES"),
641 QObject::tr("SMESH_BUT_NO"), 0, 1);
646 // Get parameters of export operation
649 int aFormat =-1; // for MED version used for write
650 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
652 // Init the parameters with the default values
653 bool aIsASCII_STL = true;
654 bool toCreateGroups = false;
656 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
657 bool toOverwrite = true;
658 bool toFindOutDim = true;
659 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
661 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
662 QString anInitialPath = "";
663 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
664 anInitialPath = QDir::currentPath();
666 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
668 // Get a file name to write in and additional options
669 if ( isUNV || isDAT || isGMF ) // Export w/o options
672 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
674 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
676 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
677 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
678 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
679 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
680 anInitialPath + QString("/") + aMeshName,
681 aFilter, aTitle, false);
683 else if ( isCGNS )// Export to CGNS
685 const char* theByTypeResource = "cgns_group_elems_by_type";
686 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
688 QStringList checkBoxes;
689 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
691 SalomeApp_CheckFileDlg* fd =
692 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
693 fd->setWindowTitle( aTitle );
694 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
695 if ( !anInitialPath.isEmpty() )
696 fd->setDirectory( anInitialPath );
697 fd->selectFile(aMeshName);
698 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
699 fd->setValidator( fv );
700 fd->SetChecked( toCreateGroups, 0 );
703 aFilename = fd->selectedFile();
704 toOverwrite = fv->isOverwrite(aFilename);
705 toCreateGroups = fd->IsChecked(0);
706 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
710 else if ( isSTL ) // Export to STL
712 QMap<QString, int> aFilterMap;
713 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
714 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
717 QMap<QString, int>::const_iterator it = aFilterMap.begin();
718 for ( ; it != aFilterMap.end(); ++it )
719 filters.push_back( it.key() );
721 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
722 fd->setWindowTitle( aTitle );
723 fd->setNameFilters( filters );
724 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
725 if ( !anInitialPath.isEmpty() )
726 fd->setDirectory( anInitialPath );
727 fd->selectFile(aMeshName);
731 aFilename = fd->selectedFile();
732 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
737 else if ( isMED || isSAUV ) // Export to MED or SAUV
739 int defaultVersion = 0;
740 QMap<QString, int> aFilterMap;
742 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
743 //QString vmed (aMesh->GetVersionString(-1, 2));
744 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
745 if ( mvok->length() > 0)
746 defaultVersion = mvok[0]; // the current version to set the default filter on it
747 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
749 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
750 MESSAGE("MED version: " << vs.toStdString());
751 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
755 aFilterMap.insert("All files (*)", -1 );
756 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
757 aFilterMap.insert("SAUV files (*.sauve)", -1 );
760 QMap<QString, int>::const_iterator it = aFilterMap.begin();
761 QString aDefaultFilter = it.key();
762 for ( ; it != aFilterMap.end(); ++it ) {
763 filters.push_back( it.key() );
764 if (it.value() == defaultVersion) // explicit default for MED = current MED version
765 aDefaultFilter = it.key();
767 QStringList checkBoxes;
768 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
770 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
771 QList< QWidget* > wdgList;
772 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
773 wdgList.append( fieldSelWdg );
775 QWidget* zTolWdg = new QWidget();
776 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
777 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
778 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
779 zTolLayout->addWidget( zTolCheck );
780 zTolLayout->addWidget( zTolSpin );
781 zTolLayout->setMargin( 0 );
782 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
783 zTolSpin->setValue( zTol );
784 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
785 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
786 zTolSpin ->setEnabled( zTolCheck->isChecked() );
787 wdgList.append( zTolWdg );
789 SalomeApp_CheckFileDlg* fd =
790 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
791 fd->setWindowTitle( aTitle );
792 fd->setNameFilters( filters );
793 fd->selectNameFilter( aDefaultFilter );
794 fd->SetChecked( toCreateGroups, 0 );
795 fd->SetChecked( toFindOutDim, 1 );
796 if ( !anInitialPath.isEmpty() )
797 fd->setDirectory( anInitialPath );
798 fd->selectFile(aMeshName);
801 QListView *lview = fd->findChild<QListView*>("listView");
803 lview->setMinimumHeight(200);
805 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
807 tview->setMinimumHeight(200);
810 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
811 fd->setValidator( fv );
816 //MESSAGE("******* Loop on file dialog ***********");
819 aFilename = fd->selectedFile();
821 aFilename = QString::null;
824 aFormat = aFilterMap[fd->selectedNameFilter()];
825 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
826 toOverwrite = fv->isOverwrite(aFilename);
827 //MESSAGE("toOverwrite:" << toOverwrite);
829 if ( !aFilename.isEmpty() ) {
831 // append is only possible if the existing file format is compatible
832 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
833 MESSAGE("Append check, isVersionOk:" << isVersionOk);
834 if ( !isVersionOk ) {
835 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
836 QObject::tr("SMESH_WRN_WARNING"),
837 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
838 QObject::tr("SMESH_BUT_YES"),
839 QObject::tr("SMESH_BUT_NO"), 0, 1);
843 //MESSAGE("incompatible MED file version for add, overwrite accepted");
849 //MESSAGE("incompatible MED file version for add, overwrite refused");
852 QStringList aMeshNamesCollisionList;
853 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
854 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
855 QString anExistingMeshName( aMeshNames[ i ] );
856 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
857 QString anExportMeshName = (*aMeshIter).second;
858 if( anExportMeshName == anExistingMeshName ) {
859 aMeshNamesCollisionList.append( anExportMeshName );
864 if( !aMeshNamesCollisionList.isEmpty() ) {
866 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
867 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
868 QObject::tr("SMESH_WRN_WARNING"),
869 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
870 QObject::tr("SMESH_BUT_YES"),
871 QObject::tr("SMESH_BUT_NO"),
872 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
873 MESSAGE("answer collision name " << aRet);
884 toCreateGroups = fd->IsChecked(0);
885 toFindOutDim = fd->IsChecked(1);
886 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
887 fieldSelWdg->GetSelectedFields();
888 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
890 if ( !fieldSelWdg->parent() )
892 if ( !zTolWdg->parent() )
903 if ( !aFilename.isEmpty() ) {
904 // Check whether the file already exists and delete it if yes
905 QFile aFile( aFilename );
906 if ( aFile.exists() && toOverwrite )
908 SUIT_OverrideCursor wc;
911 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
912 // bool Renumber = false;
913 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
915 // Renumber= resMgr->booleanValue("renumbering");
917 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
918 // aMeshEditor->RenumberNodes();
919 // aMeshEditor->RenumberElements();
920 // if ( SMESHGUI::automaticUpdate() )
921 // SMESH::UpdateView();
923 if ( isMED && isOkToWrite)
925 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
926 aMeshIter = aMeshList.begin();
927 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
929 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
930 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
931 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
932 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
933 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
934 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
935 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
936 toOverwrite && aMeshIndex == 0, toFindOutDim );
938 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
939 toCreateGroups, aFormat,
940 toOverwrite && aMeshIndex == 0, toFindOutDim,
941 fields, geoAssFields.toLatin1().data(), zTol );
946 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
948 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
949 if( !aMeshItem->_is_nil() )
950 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
955 if ( aMeshOrGroup->_is_equivalent( aMesh ))
956 aMesh->ExportDAT( aFilename.toUtf8().data() );
958 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
962 if ( aMeshOrGroup->_is_equivalent( aMesh ))
963 aMesh->ExportUNV( aFilename.toUtf8().data() );
965 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
969 if ( aMeshOrGroup->_is_equivalent( aMesh ))
970 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
972 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
976 aMeshIter = aMeshList.begin();
977 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
979 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
980 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
981 aMeshItem->ExportCGNS( aMeshOrGroup,
982 aFilename.toUtf8().data(),
983 toOverwrite && aMeshIndex == 0,
989 toCreateGroups = true;
990 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
993 catch (const SALOME::SALOME_Exception& S_ex){
995 SUIT_MessageBox::warning(SMESHGUI::desktop(),
996 QObject::tr("SMESH_WRN_WARNING"),
997 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1003 inline void InverseEntityMode(unsigned int& theOutputMode,
1004 unsigned int theMode)
1006 bool anIsNotPresent = ~theOutputMode & theMode;
1008 theOutputMode |= theMode;
1010 theOutputMode &= ~theMode;
1013 void SetDisplayEntity(int theCommandID)
1015 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1016 SALOME_ListIO selected;
1018 aSel->selectedObjects( selected );
1020 if ( selected.Extent() >= 1 ) {
1021 SUIT_OverrideCursor wc;
1022 SALOME_ListIteratorOfListIO It( selected );
1023 for( ; It.More(); It.Next()){
1024 Handle(SALOME_InteractiveObject) IObject = It.Value();
1025 if(IObject->hasEntry()){
1026 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1027 unsigned int aMode = anActor->GetEntityMode();
1028 switch(theCommandID){
1029 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1030 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1031 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1032 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1033 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1034 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1037 anActor->SetEntityMode(aMode);
1046 SalomeApp_Application* app =
1047 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1051 LightApp_SelectionMgr* aSel = app->selectionMgr();
1052 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1053 if ( !aSel || !appStudy )
1056 SALOME_ListIO selected;
1057 aSel->selectedObjects( selected );
1058 if ( selected.IsEmpty() )
1061 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1063 _PTR(Study) aStudy = appStudy->studyDS();
1064 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1065 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1066 if ( aMainObject->_is_nil() )
1069 SUIT_OverrideCursor wc;
1071 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1073 QList<SALOMEDS::Color> aReservedColors;
1075 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1076 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1078 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1080 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1081 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1082 #else // old algorithm for auto-colors
1083 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1084 aReservedColors.append( aColor );
1085 #endif // SIMPLE_AUTOCOLOR
1086 aGroupObject->SetColor( aColor );
1088 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1089 if ( aGroupSObject ) {
1092 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1093 switch ( aGroupObject->GetType ()) {
1095 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1097 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1099 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1101 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1103 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1104 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1107 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1108 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1114 SMESH::RepaintCurrentView();
1117 void OverallMeshQuality()
1119 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1120 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1121 SALOME_ListIO selected;
1123 aSel->selectedObjects( selected );
1125 if ( selected.IsEmpty() ) return;
1126 SALOME_ListIteratorOfListIO It( selected );
1127 for ( ; It.More(); It.Next() ) {
1128 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1129 ctrlDlg->showInfo( It.Value() );
1134 QString functorToString( SMESH::Controls::FunctorPtr f )
1136 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1137 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1138 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1139 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1140 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1141 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1142 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1143 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1144 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1145 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1146 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1147 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1148 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1149 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1150 type = QObject::tr( "WARP_ELEMENTS" );
1151 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1152 type = QObject::tr( "TAPER_ELEMENTS" );
1153 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1154 type = QObject::tr( "SKEW_ELEMENTS" );
1155 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1156 type = QObject::tr( "AREA_ELEMENTS" );
1157 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1158 type = QObject::tr( "LENGTH_EDGES" );
1159 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1160 type = QObject::tr( "LENGTH2D_EDGES" );
1161 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1162 type = QObject::tr( "DEFLECTION2D_FACES" );
1163 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1164 type = QObject::tr( "MULTI_BORDERS" );
1165 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1166 type = QObject::tr( "MULTI2D_BORDERS" );
1167 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1168 type = QObject::tr( "FREE_NODES" );
1169 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1170 type = QObject::tr( "FREE_EDGES" );
1171 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1172 type = QObject::tr( "FREE_BORDERS" );
1173 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1174 type = QObject::tr( "FREE_FACES" );
1175 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1176 type = QObject::tr( "BARE_BORDER_VOLUME" );
1177 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1178 type = QObject::tr( "BARE_BORDER_FACE" );
1179 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1180 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1181 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1182 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1183 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1184 type = QObject::tr( "EQUAL_NODE" );
1185 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1186 type = QObject::tr( "EQUAL_EDGE" );
1187 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1188 type = QObject::tr( "EQUAL_FACE" );
1189 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1190 type = QObject::tr( "EQUAL_VOLUME" );
1191 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1192 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1196 void SaveDistribution()
1198 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1199 SALOME_ListIO selected;
1201 aSel->selectedObjects( selected );
1203 if ( selected.Extent() == 1 ) {
1204 Handle(SALOME_InteractiveObject) anIO = selected.First();
1205 if ( anIO->hasEntry() ) {
1206 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1208 anActor->GetScalarBarActor() &&
1209 anActor->GetControlMode() != SMESH_Actor::eNone )
1211 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1212 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1213 if ( aScalarBarActor && aFunctor ) {
1214 SMESH::Controls::NumericalFunctor* aNumFun =
1215 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1217 std::vector<int> elements;
1218 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1219 if ( mesh->_is_nil() ) {
1220 SMESH::SMESH_IDSource_var idSource =
1221 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1222 if ( !idSource->_is_nil() )
1224 SMESH::long_array_var ids = idSource->GetIDs();
1225 elements.resize( ids->length() );
1226 for ( unsigned i = 0; i < elements.size(); ++i )
1227 elements[i] = ids[i];
1230 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1231 vtkLookupTable* lookupTable =
1232 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1233 double * minmax = lookupTable->GetRange();
1234 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1235 std::vector<int> nbEvents;
1236 std::vector<double> funValues;
1237 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1238 elements, minmax, isLogarithmic );
1239 QString anInitialPath = "";
1240 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1241 anInitialPath = QDir::currentPath();
1242 QString aMeshName = anIO->getName();
1244 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1245 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1246 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1247 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1248 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1251 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1253 if ( !aFilename.isEmpty() ) {
1254 QFile f( aFilename );
1255 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1256 QTextStream out( &f );
1257 out << "# Mesh: " << aMeshName << endl;
1258 out << "# Control: " << functorToString( aFunctor ) << endl;
1260 out.setFieldWidth( 10 );
1261 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1262 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1273 void ShowElement( int theCommandID )
1275 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1276 SALOME_ListIO selected;
1278 aSel->selectedObjects( selected );
1280 if ( selected.Extent() == 1 ) {
1281 Handle(SALOME_InteractiveObject) anIO = selected.First();
1282 if ( anIO->hasEntry() ) {
1283 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1285 anActor->GetScalarBarActor() &&
1286 anActor->GetControlMode() != SMESH_Actor::eNone )
1288 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1289 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1290 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1292 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1293 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1300 #ifndef DISABLE_PLOT2DVIEWER
1301 void PlotDistribution()
1303 SalomeApp_Application* app =
1304 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1308 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1309 SALOME_ListIO selected;
1311 aSel->selectedObjects( selected );
1313 if ( selected.Extent() == 1 ) {
1314 Handle(SALOME_InteractiveObject) anIO = selected.First();
1315 if ( anIO->hasEntry() ) {
1316 //Find Actor by entry before getting Plot2d viewer,
1317 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1318 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1320 SUIT_ViewManager* aViewManager =
1321 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1325 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1329 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1333 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1335 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1336 QString functorName = functorToString( anActor->GetFunctor());
1337 QString aHistogramName("%1 : %2");
1338 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1339 aHistogram->setName(aHistogramName);
1340 aHistogram->setHorTitle(functorName);
1341 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1342 aPlot->displayObject(aHistogram, true);
1347 #endif //DISABLE_PLOT2DVIEWER
1349 void DisableAutoColor()
1351 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1352 SALOME_ListIO selected;
1354 aSel->selectedObjects( selected );
1356 if ( selected.Extent() ) {
1357 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1358 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1359 if ( !aMesh->_is_nil() ) {
1360 aMesh->SetAutoColor( false );
1367 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1368 SALOME_ListIO selected;
1370 aSel->selectedObjects( selected );
1371 if ( selected.Extent() )
1373 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1374 _PTR(Study) aStudy = SMESH::getStudy();
1375 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1377 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1378 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1385 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1387 SALOME_ListIO selected;
1388 SalomeApp_Application* app =
1389 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1393 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1394 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1395 if ( !aSel || !appStudy )
1398 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1399 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1400 aModule->EmitSignalDeactivateDialog();
1401 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1402 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1407 aSel->selectedObjects( selected );
1409 if ( selected.Extent() >= 1 )
1411 switch ( theCommandID ) {
1412 case SMESHOp::OpTransparency:
1414 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1415 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1418 case SMESHOp::OpProperties:
1421 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1422 QColor orientationColor, outlineColor, volumeColor;
1423 int deltaF = 0, deltaV = 0;
1426 double ballScale = 1.0;
1428 int outlineWidth = 1;
1429 double shrinkCoef = 0.0;
1430 double orientationScale = 0.0;
1431 bool orientation3d = false;
1432 VTK::MarkerType markerType = VTK::MT_NONE;
1433 VTK::MarkerScale markerScale = VTK::MS_NONE;
1435 bool hasNodes = false;
1436 int presentEntities = 0;
1437 bool firstTime = true;
1439 SALOME_ListIteratorOfListIO It( selected );
1440 for ( ; It.More(); It.Next() ) {
1441 Handle(SALOME_InteractiveObject) IObject = It.Value();
1442 if ( !IObject->hasEntry() ) continue;
1443 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1444 if ( !anActor || !anActor->GetObject() ) continue;
1447 // nodes: color, marker
1448 anActor->GetNodeColor( color[0], color[1], color[2] );
1449 nodeColor.setRgbF( color[0], color[1], color[2] );
1450 markerType = anActor->GetMarkerType();
1451 markerScale = anActor->GetMarkerScale();
1452 markerId = anActor->GetMarkerTexture();
1453 // edges: color, width
1454 anActor->GetEdgeColor( color[0], color[1], color[2] );
1455 edgeColor.setRgbF( color[0], color[1], color[2] );
1456 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1457 // faces: front color, back color (delta)
1458 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1459 faceColor.setRgbF( color[0], color[1], color[2] );
1460 // faces: front color, back color (delta)
1461 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1462 volumeColor.setRgbF( color[0], color[1], color[2] );
1463 // 0d elements: color, size
1464 anActor->Get0DColor( color[0], color[1], color[2] );
1465 elem0dColor.setRgbF( color[0], color[1], color[2] );
1466 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1467 // balls: color, size
1468 anActor->GetBallColor( color[0], color[1], color[2] );
1469 ballColor.setRgbF( color[0], color[1], color[2] );
1470 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1471 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1473 anActor->GetOutlineColor( color[0], color[1], color[2] );
1474 outlineColor.setRgbF( color[0], color[1], color[2] );
1475 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1476 // orientation vectors: color, scale, 3d flag
1477 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1478 orientationColor.setRgbF( color[0], color[1], color[2] );
1479 orientationScale = anActor->GetFacesOrientationScale();
1480 orientation3d = anActor->GetFacesOrientation3DVectors();
1482 shrinkCoef = anActor->GetShrinkFactor();
1485 firstTime = false; // we only take properties from first object (for performance reasons)
1488 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1489 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1490 presentEntities = presentEntities | SMESH_Actor::eEdges;
1491 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1492 presentEntities = presentEntities | SMESH_Actor::eFaces;
1493 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1494 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1495 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1496 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1497 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1498 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1500 // as we know that all types of elements are present, we can exit the loop
1501 if ( presentEntities == SMESH_Actor::eAllEntity )
1505 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1506 // nodes: color, marker
1507 dlg.setNodeColor( nodeColor );
1508 if( markerType != VTK::MT_USER )
1509 dlg.setNodeMarker( markerType, markerScale );
1511 dlg.setNodeCustomMarker( markerId );
1512 // edges: color, line width
1513 dlg.setEdgeColor( edgeColor );
1514 dlg.setEdgeWidth( edgeWidth );
1515 // faces: front color, back color
1516 dlg.setFaceColor( faceColor, deltaF );
1517 // volumes: normal color, reversed color
1518 dlg.setVolumeColor( volumeColor, deltaV );
1519 // outlines: color, line width
1520 dlg.setOutlineColor( outlineColor );
1521 dlg.setOutlineWidth( outlineWidth );
1522 // 0d elements: color, size
1523 dlg.setElem0dColor( elem0dColor );
1524 dlg.setElem0dSize( elem0dSize );
1525 // balls: color, size
1526 dlg.setBallColor( ballColor );
1527 //dlg.setBallSize( ballSize );
1528 dlg.setBallScale( ballScale );
1529 // orientation: color, scale, 3d flag
1530 dlg.setOrientationColor( orientationColor );
1531 dlg.setOrientationSize( int( orientationScale * 100. ) );
1532 dlg.setOrientation3d( orientation3d );
1533 // shrink: scale factor
1534 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1535 // hide unused controls
1536 dlg.showControls( presentEntities, hasNodes );
1539 nodeColor = dlg.nodeColor();
1540 markerType = dlg.nodeMarkerType();
1541 markerScale = dlg.nodeMarkerScale();
1542 markerId = dlg.nodeMarkerId();
1543 edgeColor = dlg.edgeColor();
1544 edgeWidth = dlg.edgeWidth();
1545 faceColor = dlg.faceColor();
1546 deltaF = dlg.faceColorDelta();
1547 volumeColor = dlg.volumeColor();
1548 deltaV = dlg.volumeColorDelta();
1549 outlineColor = dlg.outlineColor();
1550 outlineWidth = dlg.outlineWidth();
1551 elem0dColor = dlg.elem0dColor();
1552 elem0dSize = dlg.elem0dSize();
1553 ballColor = dlg.ballColor();
1554 // ballSize = dlg.ballSize();
1555 ballScale = dlg.ballScale();
1556 orientationColor = dlg.orientationColor();
1557 orientationScale = dlg.orientationSize() / 100.;
1558 orientation3d = dlg.orientation3d();
1559 shrinkCoef = dlg.shrinkCoef() / 100.;
1561 // store point markers that might be changed by the user
1562 theMarkerMap = dlg.customMarkers();
1564 // set properties from dialog box to the presentations
1565 SALOME_ListIteratorOfListIO It( selected );
1566 for ( ; It.More(); It.Next() ) {
1567 Handle(SALOME_InteractiveObject) IObject = It.Value();
1568 if ( !IObject->hasEntry() ) continue;
1569 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1570 if ( !anActor ) continue;
1572 // nodes: color, marker
1573 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1574 if ( markerType != VTK::MT_USER ) {
1575 anActor->SetMarkerStd( markerType, markerScale );
1578 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1579 if ( iter != theMarkerMap.end() )
1580 anActor->SetMarkerTexture( markerId, iter->second.second );
1582 // volumes: normal color, reversed color (delta)
1583 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1584 // faces: front color, back color (delta)
1585 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1586 // edges: color, width
1587 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1588 anActor->SetLineWidth( edgeWidth );
1590 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1591 anActor->SetOutlineWidth( outlineWidth );
1592 // 0D elements: color, size
1593 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1594 anActor->Set0DSize( elem0dSize );
1595 // balls: color, size
1596 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1597 // anActor->SetBallSize( ballSize );
1598 anActor->SetBallScale( ballScale );
1599 // orientation: color, scale, 3d flag
1600 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1601 anActor->SetFacesOrientationScale( orientationScale );
1602 anActor->SetFacesOrientation3DVectors( orientation3d );
1604 anActor->SetShrinkFactor( shrinkCoef );
1606 // for groups, set also proper color
1607 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1608 if ( !aGroupObject->_is_nil() ) {
1609 SMESH::ElementType anElementType = aGroupObject->GetType();
1611 switch( anElementType ) {
1613 aColor = nodeColor; break;
1615 aColor = edgeColor; break;
1617 aColor = faceColor; break;
1619 aColor = volumeColor; break;
1621 aColor = elem0dColor; break;
1623 aColor = ballColor; break;
1627 if ( aColor.isValid() ) {
1628 SALOMEDS::Color aGroupColor;
1629 aGroupColor.R = aColor.redF();
1630 aGroupColor.G = aColor.greenF();
1631 aGroupColor.B = aColor.blueF();
1632 aGroupObject->SetColor( aGroupColor );
1634 } // if ( !aGroupObject->_is_nil() )
1635 } // for ( ; It.More(); It.Next() )
1636 SMESH::RepaintCurrentView();
1637 } // if ( dlg.exec() )
1639 } // case SMESHOp::OpProperties:
1640 } // switch(theCommandID)
1641 SUIT_OverrideCursor wc;
1642 SALOME_ListIteratorOfListIO It( selected );
1643 for( ; It.More(); It.Next()){
1644 Handle(SALOME_InteractiveObject) IObject = It.Value();
1645 if(IObject->hasEntry()){
1646 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1647 switch(theCommandID){
1648 case SMESHOp::OpDMWireframe:
1649 anActor->SetRepresentation(SMESH_Actor::eEdge);
1651 case SMESHOp::OpDMShading:
1652 anActor->SetRepresentation(SMESH_Actor::eSurface);
1654 case SMESHOp::OpDMShrink:
1655 if(anActor->IsShrunk())
1656 anActor->UnShrink();
1658 anActor->SetShrink();
1660 case SMESHOp::OpDMNodes:
1661 anActor->SetRepresentation(SMESH_Actor::ePoint);
1663 case SMESHOp::OpRepresentationLines:
1664 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1665 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1667 case SMESHOp::OpRepresentationArcs:
1668 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1669 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1675 SMESH::RepaintCurrentView();
1679 int ActionToControl( int theID, bool theReversed )
1681 NCollection_DoubleMap<int,int> ActionControl;
1682 ActionControl.Bind( 0, SMESH_Actor::eNone );
1683 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1684 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1685 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1686 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1687 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1688 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1689 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1690 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1691 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1692 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1693 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1694 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1695 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1696 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1697 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1698 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1699 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1700 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1701 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1702 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1703 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1704 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1705 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1706 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1707 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1708 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1709 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1710 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1713 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1714 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1717 void Control( int theCommandID )
1719 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1720 _PTR(Study) aStudy = SMESH::getStudy();
1722 SALOME_ListIO selected;
1723 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1724 aSel->selectedObjects( selected );
1726 if ( !selected.IsEmpty() ) {
1727 SALOME_ListIteratorOfListIO It(selected);
1728 for ( ; It.More(); It.Next())
1730 Handle(SALOME_InteractiveObject) anIO = It.Value();
1731 if ( !anIO.IsNull() ) {
1732 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1734 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1735 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1736 if ( !anIDSrc->_is_nil() ) {
1737 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1738 if (( !anActor && selected.Extent() == 1 ) &&
1739 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1741 anActor->SetControlMode( aControl );
1742 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1743 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1747 if ( anActor->GetControlMode() != aControl )
1748 anActor->SetControlMode( aControl );
1749 QString functorName = functorToString( anActor->GetFunctor() );
1750 int anEntitiesCount = anActor->GetNumberControlEntities();
1751 if (anEntitiesCount >= 0)
1752 functorName = functorName + ": " + QString::number(anEntitiesCount);
1753 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1754 SMESH::RepaintCurrentView();
1755 #ifndef DISABLE_PLOT2DVIEWER
1756 if ( anActor->GetPlot2Histogram() ) {
1757 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1758 QString aHistogramName("%1 : %2");
1759 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1760 aHistogram->setName( aHistogramName );
1761 aHistogram->setHorTitle( functorName );
1762 SMESH::ProcessIn2DViewers( anActor );
1774 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1775 SMESH::MeshObjectType theType,
1776 const QString theInTypeName,
1777 QString & theOutTypeName)
1779 SMESH_TypeFilter aTypeFilter( theType );
1781 if ( !theIO.IsNull() )
1783 entry = theIO->getEntry();
1784 LightApp_DataOwner owner( entry );
1785 if ( aTypeFilter.isOk( &owner )) {
1786 theOutTypeName = theInTypeName;
1794 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1796 _PTR(Study) aStudy = SMESH::getStudy();
1797 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1799 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1800 CORBA::String_var anID = aSComp->GetID().c_str();
1801 if ( !strcmp(anID.in(),theIO->getEntry()) )
1807 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1808 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1809 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1810 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1811 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1819 // QString CheckHomogeneousSelection()
1821 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1822 // SALOME_ListIO selected;
1824 // aSel->selectedObjects( selected );
1826 // QString RefType = CheckTypeObject(selected.First());
1827 // SALOME_ListIteratorOfListIO It(selected);
1828 // for ( ; It.More(); It.Next())
1830 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1831 // QString Type = CheckTypeObject(IObject);
1832 // if ( Type.compare(RefType) != 0 )
1833 // return "Heterogeneous Selection";
1839 uint randomize( uint size )
1841 static bool initialized = false;
1842 if ( !initialized ) {
1843 qsrand( QDateTime::currentDateTime().toTime_t() );
1847 v = uint( (double)( v ) / RAND_MAX * size );
1848 v = qMax( uint(0), qMin ( v, size-1 ) );
1854 void SMESHGUI::OnEditDelete()
1856 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1857 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1858 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1860 _PTR(Study) aStudy = SMESH::getStudy();
1861 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1862 _PTR(GenericAttribute) anAttr;
1863 _PTR(AttributeIOR) anIOR;
1865 const int objectCountLimit = 30; // PAL23599
1866 int objectCount = 0;
1868 QString aParentComponent = QString::null;
1870 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1872 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1873 if ( anIO.IsNull() ) continue;
1875 QString father = "unknown", name;
1877 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1879 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1880 // check if object is reference
1881 _PTR(SObject) aRefSObj;
1882 if ( aSO->ReferencedObject( aRefSObj ) ) {
1883 name = QString::fromStdString ( aRefSObj->GetName() );
1884 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1887 name = anIO->getName();
1890 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1891 aNameList.append("\n - ");
1892 aNameList.append( name );
1895 if( aParentComponent.isNull() )
1896 aParentComponent = father;
1897 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1898 aParentComponent = "";
1900 if ( objectCount >= objectCountLimit )
1901 aNameList.append("\n - ...");
1903 if ( objectCount == 0 )
1904 return; // No Valid Objects Selected
1906 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1907 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1908 QObject::tr("ERR_ERROR"),
1909 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1912 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1913 if (SUIT_MessageBox::warning
1914 (SMESHGUI::desktop(),
1915 QObject::tr("SMESH_WRN_WARNING"),
1916 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1917 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1918 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1921 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1923 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1924 // then treat them all starting from the deepest objects (at list back)
1925 std::list< _PTR(SObject) > listSO;
1926 SALOME_ListIteratorOfListIO It(selected);
1927 for( ; It.More(); It.Next()) // loop on selected IO's
1929 Handle(SALOME_InteractiveObject) IObject = It.Value();
1930 if(IObject->hasEntry()) {
1931 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1933 // disable removal of "SMESH" component object
1934 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1936 if ( engineIOR() == anIOR->Value().c_str() )
1939 //Check the referenced object
1940 _PTR(SObject) aRefSObject;
1941 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1942 aSO = aRefSObject; // Delete main Object instead of reference
1944 listSO.push_back( aSO );
1945 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1946 for ( ; itSO != listSO.end(); ++itSO ) {
1947 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1948 for (it->InitEx(false); it->More(); it->Next())
1949 listSO.push_back( it->Value() );
1953 // Check if none of objects to delete is referred from outside
1954 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1955 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1957 _PTR(SObject) SO = *ritSO;
1958 if ( !SO ) continue;
1959 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1960 for (size_t i = 0; i < aReferences.size(); i++) {
1961 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1962 std::string type = aComponent->ComponentDataType();
1963 if ( type != "SMESH" )
1965 SUIT_MessageBox::warning( anApp->desktop(),
1966 QObject::tr("WRN_WARNING"),
1967 QObject::tr("DEP_OBJECT") );
1968 return; // outside SMESH, there is an object depending on a SMESH object
1973 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1974 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1976 Handle(SALOME_InteractiveObject) IObject = It.Value();
1977 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1978 if ( !mesh->_is_nil() )
1982 // Treat SO's in the list starting from the back
1983 aStudyBuilder->NewCommand(); // There is a transaction
1984 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1986 _PTR(SObject) SO = *ritSO;
1987 if ( !SO ) continue;
1988 std::string anEntry = SO->GetID();
1990 /** Erase graphical object and remove all its data **/
1991 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1992 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1994 /** Remove an object from data structures **/
1995 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1996 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1997 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1998 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1999 aMesh->RemoveGroup( aGroup );
2001 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2002 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2003 aMesh->RemoveSubMesh( aSubMesh );
2006 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2007 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2008 QString objType = CheckTypeObject(IObject);
2009 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2010 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2011 aStudyBuilder->RemoveObjectWithChildren( SO );
2013 else {// default action: remove SObject from the study
2014 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2015 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2017 aStudyBuilder->RemoveObjectWithChildren( SO );
2021 } /* listSO back loop */
2023 aStudyBuilder->CommitCommand();
2025 /* Clear any previous selection */
2027 aSel->setSelectedObjects( l1 );
2029 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2033 SMESHGUI_EXPORT CAM_Module* createModule()
2035 return new SMESHGUI();
2038 SMESHGUI_EXPORT char* getModuleVersion() {
2039 return (char*)SMESH_VERSION_STR;
2043 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2045 //=============================================================================
2049 //=============================================================================
2050 SMESHGUI::SMESHGUI() :
2051 SalomeApp_Module( "SMESH" )
2053 if ( CORBA::is_nil( myComponentSMESH ) )
2055 CORBA::Boolean anIsEmbeddedMode;
2056 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2057 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2059 // 0019923: EDF 765 SMESH : default values of hypothesis
2060 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2061 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2062 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2063 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2064 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2066 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2067 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2068 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2070 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2071 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2075 myActiveDialogBox = 0;
2076 myFilterLibraryDlg = 0;
2080 myEventCallbackCommand = vtkCallbackCommand::New();
2081 myEventCallbackCommand->Delete();
2082 myEventCallbackCommand->SetClientData( this );
2083 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2086 /* load resources for all available meshers */
2087 SMESH::InitAvailableHypotheses();
2090 //=============================================================================
2094 //=============================================================================
2095 SMESHGUI::~SMESHGUI()
2099 //=============================================================================
2103 //=============================================================================
2104 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2106 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2108 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2113 //=============================================================================
2117 //=============================================================================
2118 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2120 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2124 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2125 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2126 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2127 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2128 return autoUpdate && !exceeded;
2131 //=============================================================================
2135 //=============================================================================
2136 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2137 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2139 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2143 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2144 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2145 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2147 SMESH::long_array_var info = theMesh->GetMeshInfo();
2148 long nbOdElems = info[SMDSEntity_0D];
2149 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2150 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2151 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2152 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2153 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2154 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2155 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2156 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2157 info[SMDSEntity_Polyhedra] +
2158 info[SMDSEntity_Hexagonal_Prism];
2159 long nbBalls = info[SMDSEntity_Ball];
2161 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2162 *nbElements = requestedSize;
2164 *entities = SMESH_Actor::eAllEntity;
2167 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2169 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2171 if ( incrementalLimit ) {
2174 if ( nbOdElems > 0 ) {
2175 if ( total + nbOdElems > updateLimit ) {
2176 *entities = *entities & ~SMESH_Actor::e0DElements;
2177 *hidden = *hidden | SMESH_Actor::e0DElements;
2184 if ( nbEdges > 0 ) {
2185 if ( total + nbEdges > updateLimit ) {
2186 *entities = *entities & ~SMESH_Actor::eEdges;
2187 *hidden = *hidden | SMESH_Actor::eEdges;
2194 if ( nbFaces > 0 ) {
2195 if ( total + nbFaces > updateLimit ) {
2196 *entities = *entities & ~SMESH_Actor::eFaces;
2197 *hidden = *hidden | SMESH_Actor::eFaces;
2204 if ( nbVolumes > 0 ) {
2205 if ( total + nbVolumes > updateLimit ) {
2206 *entities = *entities & ~SMESH_Actor::eVolumes;
2207 *hidden = *hidden | SMESH_Actor::eVolumes;
2214 if ( nbBalls > 0 ) {
2215 if ( total + nbBalls > updateLimit ) {
2216 *entities = *entities & ~SMESH_Actor::eBallElem;
2217 *hidden = *hidden | SMESH_Actor::eBallElem;
2225 return autoUpdate && !exceeded;
2228 //=============================================================================
2232 //=============================================================================
2233 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2235 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2238 //=============================================================================
2242 //=============================================================================
2243 SMESHGUI* SMESHGUI::GetSMESHGUI()
2245 SMESHGUI* smeshMod = 0;
2246 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2249 CAM_Module* module = app->module( "Mesh" );
2250 smeshMod = dynamic_cast<SMESHGUI*>( module );
2258 Standard_EXPORT SMESHGUI* GetComponentGUI()
2260 return SMESHGUI::GetSMESHGUI();
2264 //=============================================================================
2268 //=============================================================================
2269 void SMESHGUI::SetState(int aState)
2274 //=============================================================================
2278 //=============================================================================
2279 void SMESHGUI::ResetState()
2284 //=============================================================================
2288 //=============================================================================
2289 void SMESHGUI::EmitSignalDeactivateDialog()
2291 emit SignalDeactivateActiveDialog();
2294 //=============================================================================
2298 //=============================================================================
2299 void SMESHGUI::EmitSignalStudyFrameChanged()
2301 emit SignalStudyFrameChanged();
2304 //=============================================================================
2308 //=============================================================================
2309 void SMESHGUI::EmitSignalCloseAllDialogs()
2311 emit SignalCloseAllDialogs();
2314 //=============================================================================
2318 //=============================================================================
2319 void SMESHGUI::EmitSignalVisibilityChanged()
2321 emit SignalVisibilityChanged();
2324 //=============================================================================
2328 //=============================================================================
2329 void SMESHGUI::EmitSignalCloseView()
2331 emit SignalCloseView();
2334 //=============================================================================
2338 //=============================================================================
2339 void SMESHGUI::EmitSignalActivatedViewManager()
2341 emit SignalActivatedViewManager();
2344 //=============================================================================
2348 //=============================================================================
2349 QDialog *SMESHGUI::GetActiveDialogBox()
2351 return myActiveDialogBox;
2354 //=============================================================================
2358 //=============================================================================
2359 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2361 myActiveDialogBox = (QDialog *) aDlg;
2365 //=============================================================================
2369 //=============================================================================
2370 SUIT_Desktop* SMESHGUI::desktop()
2372 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2374 return app->desktop();
2379 //=============================================================================
2383 //=============================================================================
2384 SalomeApp_Study* SMESHGUI::activeStudy()
2386 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2388 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2393 //=============================================================================
2397 //=============================================================================
2398 void SMESHGUI::Modified( bool theIsUpdateActions )
2400 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2401 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2402 appStudy->Modified();
2403 if( theIsUpdateActions )
2404 app->updateActions();
2409 //=============================================================================
2413 //=============================================================================
2414 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2416 /* Here the position is on the bottom right corner - 10 */
2417 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2419 SUIT_Desktop *PP = desktop();
2420 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2421 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2426 * \brief Verifies whether study of operation is locked
2427 * \param theMess - specifies whether message box must be shown if study is locked
2428 * \return State of study.
2430 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2431 * is locked when corresponding message box appears
2433 bool SMESHGUI::isStudyLocked( bool theMessage )
2435 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2438 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2439 QObject::tr( "WRN_WARNING" ),
2440 QObject::tr( "WRN_STUDY_LOCKED" ) );
2446 //=============================================================================
2450 //=============================================================================
2451 bool SMESHGUI::OnGUIEvent( int theCommandID )
2453 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2457 SUIT_ResourceMgr* mgr = resourceMgr();
2461 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2462 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2464 //QAction* act = action( theCommandID );
2466 switch (theCommandID) {
2467 case SMESHOp::OpDelete:
2468 if(isStudyLocked()) break;
2471 case SMESHOp::OpImportDAT:
2472 case SMESHOp::OpImportUNV:
2473 case SMESHOp::OpImportMED:
2474 case SMESHOp::OpImportSTL:
2475 case SMESHOp::OpImportCGNS:
2476 case SMESHOp::OpImportSAUV:
2477 case SMESHOp::OpImportGMF:
2478 case SMESHOp::OpPopupImportDAT:
2479 case SMESHOp::OpPopupImportUNV:
2480 case SMESHOp::OpPopupImportMED:
2481 case SMESHOp::OpPopupImportSTL:
2482 case SMESHOp::OpPopupImportCGNS:
2483 case SMESHOp::OpPopupImportSAUV:
2484 case SMESHOp::OpPopupImportGMF:
2486 if(isStudyLocked()) break;
2487 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2491 case SMESHOp::OpFileInformation:
2493 SALOME_ListIO selected;
2494 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2496 aSel->selectedObjects( selected );
2497 if( selected.Extent() )
2499 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2500 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2501 if ( !aMesh->_is_nil() )
2503 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2509 case SMESHOp::OpExportDAT:
2510 case SMESHOp::OpExportMED:
2511 case SMESHOp::OpExportUNV:
2512 case SMESHOp::OpExportSTL:
2513 case SMESHOp::OpExportCGNS:
2514 case SMESHOp::OpExportSAUV:
2515 case SMESHOp::OpExportGMF:
2516 case SMESHOp::OpPopupExportDAT:
2517 case SMESHOp::OpPopupExportMED:
2518 case SMESHOp::OpPopupExportUNV:
2519 case SMESHOp::OpPopupExportSTL:
2520 case SMESHOp::OpPopupExportCGNS:
2521 case SMESHOp::OpPopupExportSAUV:
2522 case SMESHOp::OpPopupExportGMF:
2524 ::ExportMeshToFile(theCommandID);
2528 case SMESHOp::OpReset: // SCALAR BAR
2530 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2531 SALOME_ListIO selected;
2533 aSel->selectedObjects( selected );
2535 SALOME_ListIteratorOfListIO it(selected);
2536 for( ; it.More(); it.Next()) {
2537 Handle(SALOME_InteractiveObject) anIO = it.Value();
2538 if( anIO->hasEntry() ) {
2539 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2540 anActor->SetControlMode( SMESH_Actor::eNone );
2541 #ifndef DISABLE_PLOT2DVIEWER
2542 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2544 anActor->UpdateFilter();
2548 SMESH::UpdateView();
2551 case SMESHOp::OpScalarBarProperties:
2553 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2556 case SMESHOp::OpShowScalarBar:
2558 // show/hide scalar bar
2559 ::ShowElement(theCommandID);
2562 case SMESHOp::OpSaveDistribution:
2564 // dump control distribution data to the text file
2565 ::SaveDistribution();
2569 case SMESHOp::OpShowDistribution:
2571 // show/hide distribution
2572 ::ShowElement(theCommandID);
2576 #ifndef DISABLE_PLOT2DVIEWER
2577 case SMESHOp::OpPlotDistribution:
2579 // plot distribution
2580 ::PlotDistribution();
2586 case SMESHOp::OpAutoColor:
2590 case SMESHOp::OpDisableAutoColor:
2591 ::DisableAutoColor();
2594 case SMESHOp::OpClipping:
2595 case SMESHOp::OpTransparency:
2596 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2599 case SMESHOp::OpDMWireframe:
2600 case SMESHOp::OpDMShading:
2601 case SMESHOp::OpDMNodes:
2602 case SMESHOp::OpDMShrink:
2603 ::SetDisplayMode(theCommandID, myMarkerMap);
2606 //2D quadratic representation
2607 case SMESHOp::OpRepresentationLines:
2608 case SMESHOp::OpRepresentationArcs:
2609 ::SetDisplayMode(theCommandID, myMarkerMap);
2613 case SMESHOp::OpDE0DElements:
2614 case SMESHOp::OpDEEdges:
2615 case SMESHOp::OpDEFaces:
2616 case SMESHOp::OpDEVolumes:
2617 case SMESHOp::OpDEBalls:
2618 case SMESHOp::OpDEAllEntity:
2619 ::SetDisplayEntity(theCommandID);
2622 // Choose entities to be displayed
2623 case SMESHOp::OpDEChoose:
2625 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2629 case SMESHOp::OpOrientationOnFaces:
2631 SUIT_OverrideCursor wc;
2632 LightApp_SelectionMgr* mgr = selectionMgr();
2633 SALOME_ListIO selected; mgr->selectedObjects( selected );
2635 SALOME_ListIteratorOfListIO it(selected);
2636 for( ; it.More(); it.Next()) {
2637 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2638 if(anIObject->hasEntry()) {
2639 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2640 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2647 case SMESHOp::OpUpdate:
2649 if(isStudyLocked()) break;
2650 SUIT_OverrideCursor wc;
2653 SMESH::UpdateView();
2655 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2656 SMESH::OnVisuException();
2658 catch (...) { // PAL16774 (Crash after display of many groups)
2659 SMESH::OnVisuException();
2663 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2664 aSel->selectedObjects( l );
2665 aSel->setSelectedObjects( l );
2669 case SMESHOp::OpHide:
2670 case SMESHOp::OpShow:
2671 case SMESHOp::OpShowOnly:
2673 SUIT_OverrideCursor wc;
2674 SMESH::EDisplaing anAction;
2675 switch (theCommandID) {
2676 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2677 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2678 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2681 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2682 SALOME_ListIO sel_objects, to_process;
2684 aSel->selectedObjects( sel_objects );
2686 if ( theCommandID==SMESHOp::OpShowOnly )
2688 //MESSAGE("anAction = SMESH::eDisplayOnly");
2689 startOperation( myEraseAll );
2692 extractContainers( sel_objects, to_process );
2697 SALOME_ListIteratorOfListIO It( to_process );
2698 for ( ; It.More(); It.Next())
2700 Handle(SALOME_InteractiveObject) IOS = It.Value();
2701 if ( IOS->hasEntry() )
2703 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2704 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2705 break; // PAL16774 (Crash after display of many groups)
2707 if (anAction == SMESH::eDisplayOnly)
2708 anAction = SMESH::eDisplay;
2713 // PAL13338 + PAL15161 -->
2714 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2715 SMESH::UpdateView();
2716 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2718 // PAL13338 + PAL15161 <--
2720 catch (...) { // PAL16774 (Crash after display of many groups)
2721 SMESH::OnVisuException();
2724 if (anAction == SMESH::eErase) {
2726 aSel->setSelectedObjects( l1 );
2729 aSel->setSelectedObjects( to_process );
2731 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2732 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2733 vtkwnd->GetRenderer()->AdjustActors();
2738 case SMESHOp::OpNode:
2740 if(isStudyLocked()) break;
2743 EmitSignalDeactivateDialog();
2745 ( new SMESHGUI_NodesDlg( this ) )->show();
2748 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2753 case SMESHOp::OpCreateMesh:
2754 case SMESHOp::OpCreateSubMesh:
2755 case SMESHOp::OpEditMeshOrSubMesh:
2756 case SMESHOp::OpEditMesh:
2757 case SMESHOp::OpEditSubMesh:
2758 case SMESHOp::OpCompute:
2759 case SMESHOp::OpComputeSubMesh:
2760 case SMESHOp::OpPreCompute:
2761 case SMESHOp::OpEvaluate:
2762 case SMESHOp::OpMeshOrder:
2763 startOperation( theCommandID );
2765 case SMESHOp::OpCopyMesh:
2767 if (isStudyLocked()) break;
2768 EmitSignalDeactivateDialog();
2769 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2772 case SMESHOp::OpBuildCompoundMesh:
2774 if (isStudyLocked()) break;
2775 EmitSignalDeactivateDialog();
2776 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2780 case SMESHOp::OpDiagonalInversion:
2781 case SMESHOp::OpUnionOfTwoTriangle:
2785 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2789 if ( isStudyLocked() )
2792 /*Standard_Boolean aRes;
2793 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2794 if ( aMesh->_is_nil() )
2796 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2797 tr( "SMESH_BAD_SELECTION" ) );
2801 EmitSignalDeactivateDialog();
2802 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2803 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2805 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2808 case SMESHOp::OpOrientation:
2809 case SMESHOp::OpUnionOfTriangles:
2810 case SMESHOp::OpCuttingOfQuadrangles:
2811 case SMESHOp::OpSplitVolumes:
2815 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2819 if ( isStudyLocked() )
2822 EmitSignalDeactivateDialog();
2823 SMESHGUI_MultiEditDlg* aDlg = NULL;
2824 if ( theCommandID == SMESHOp::OpOrientation )
2825 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2826 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2827 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2828 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2829 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2831 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2836 case SMESHOp::OpSmoothing:
2838 if(isStudyLocked()) break;
2840 EmitSignalDeactivateDialog();
2841 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2844 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2848 case SMESHOp::OpExtrusion:
2850 if (isStudyLocked()) break;
2852 EmitSignalDeactivateDialog();
2853 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2855 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2859 case SMESHOp::OpExtrusionAlongAPath:
2861 if (isStudyLocked()) break;
2863 EmitSignalDeactivateDialog();
2864 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2866 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2870 case SMESHOp::OpRevolution:
2872 if(isStudyLocked()) break;
2874 EmitSignalDeactivateDialog();
2875 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2878 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2882 case SMESHOp::OpPatternMapping:
2884 if ( isStudyLocked() )
2888 EmitSignalDeactivateDialog();
2889 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2892 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2896 case SMESHOp::OpSplitBiQuadratic:
2897 case SMESHOp::OpConvertMeshToQuadratic:
2898 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2899 case SMESHOp::OpReorientFaces:
2900 case SMESHOp::OpCreateGeometryGroup:
2902 startOperation( theCommandID );
2905 case SMESHOp::OpCreateGroup:
2909 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2913 if(isStudyLocked()) break;
2914 EmitSignalDeactivateDialog();
2915 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2917 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2918 SALOME_ListIO selected;
2920 aSel->selectedObjects( selected );
2922 int nbSel = selected.Extent();
2924 // check if mesh is selected
2925 aMesh = SMESH::GetMeshByIO( selected.First() );
2927 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2932 case SMESHOp::OpConstructGroup:
2936 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2940 if(isStudyLocked()) break;
2941 EmitSignalDeactivateDialog();
2943 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2944 SALOME_ListIO selected;
2946 aSel->selectedObjects( selected );
2948 int nbSel = selected.Extent();
2950 // check if submesh is selected
2951 Handle(SALOME_InteractiveObject) IObject = selected.First();
2952 if (IObject->hasEntry()) {
2953 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2955 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2956 if (!aSubMesh->_is_nil()) {
2958 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2959 // get submesh elements list by types
2960 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2961 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2962 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2963 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2964 // create group for each type o elements
2965 QString aName = IObject->getName();
2966 QStringList anEntryList;
2967 if (aNodes->length() > 0) {
2968 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2969 aGroup->Add(aNodes.inout());
2970 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2971 anEntryList.append( aSObject->GetID().c_str() );
2973 if (aEdges->length() > 0) {
2974 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2975 aGroup->Add(aEdges.inout());
2976 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2977 anEntryList.append( aSObject->GetID().c_str() );
2979 if (aFaces->length() > 0) {
2980 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2981 aGroup->Add(aFaces.inout());
2982 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2983 anEntryList.append( aSObject->GetID().c_str() );
2985 if (aVolumes->length() > 0) {
2986 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2987 aGroup->Add(aVolumes.inout());
2988 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2989 anEntryList.append( aSObject->GetID().c_str() );
2992 anApp->browseObjects( anEntryList );
2994 catch(const SALOME::SALOME_Exception & S_ex){
2995 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3002 SUIT_MessageBox::warning(desktop(),
3003 tr("SMESH_WRN_WARNING"),
3004 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3009 case SMESHOp::OpEditGroup:
3013 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3017 if(isStudyLocked()) break;
3018 EmitSignalDeactivateDialog();
3020 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3021 SALOME_ListIO selected;
3023 aSel->selectedObjects( selected );
3025 SALOME_ListIteratorOfListIO It (selected);
3026 int nbSelectedGroups = 0;
3027 for ( ; It.More(); It.Next() )
3029 SMESH::SMESH_GroupBase_var aGroup =
3030 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3031 if (!aGroup->_is_nil()) {
3033 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3037 if (nbSelectedGroups == 0)
3039 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3045 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3047 if(isStudyLocked()) break;
3048 if (myState == 800) {
3049 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3050 if (aDlg) aDlg->onAdd();