1 // Copyright (C) 2007-2021 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_MG_ADAPTDRIVER.h"
64 #include "SMESHGUI_Make2DFrom3DOp.h"
65 #include "SMESHGUI_MakeNodeAtPointDlg.h"
66 #include "SMESHGUI_Measurements.h"
67 #include "SMESHGUI_MergeDlg.h"
68 #include "SMESHGUI_MeshInfo.h"
69 #include "SMESHGUI_MeshOp.h"
70 #include "SMESHGUI_MeshOrderOp.h"
71 #include "SMESHGUI_MeshPatternDlg.h"
72 #include "SMESHGUI_MeshUtils.h"
73 #include "SMESHGUI_MultiEditDlg.h"
74 #include "SMESHGUI_NodesDlg.h"
75 #include "SMESHGUI_OffsetDlg.h"
76 #include "SMESHGUI_Operations.h"
77 #include "SMESHGUI_PatternUtils.h"
78 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
79 #include "SMESHGUI_PropertiesDlg.h"
80 #include "SMESHGUI_RemoveElementsDlg.h"
81 #include "SMESHGUI_RemoveNodesDlg.h"
82 #include "SMESHGUI_RenumberingDlg.h"
83 #include "SMESHGUI_ReorientFacesDlg.h"
84 #include "SMESHGUI_RevolutionDlg.h"
85 #include "SMESHGUI_RotationDlg.h"
86 #include "SMESHGUI_ScaleDlg.h"
87 #include "SMESHGUI_Selection.h"
88 #include "SMESHGUI_SewingDlg.h"
89 #include "SMESHGUI_SingleEditDlg.h"
90 #include "SMESHGUI_SmoothingDlg.h"
91 #include "SMESHGUI_SpinBox.h"
92 #include "SMESHGUI_SplitBiQuad.h"
93 #include "SMESHGUI_SymmetryDlg.h"
94 #include "SMESHGUI_TranslationDlg.h"
95 #include "SMESHGUI_TransparencyDlg.h"
96 #include "SMESHGUI_Utils.h"
97 #include "SMESHGUI_VTKUtils.h"
99 #include "SMESH_version.h"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_Comment.hxx"
105 #include "SMESH_ControlsDef.hxx"
106 #include "SMESH_ScalarBarActor.h"
107 #include "SMESH_TypeFilter.hxx"
108 #include "SMESH_Component_Generator.hxx"
110 // SALOME GUI includes
111 #include <LightApp_DataOwner.h>
112 #include <LightApp_NameDlg.h>
113 #include <LightApp_Preferences.h>
114 #include <LightApp_SelectionMgr.h>
115 #include <LightApp_UpdateFlags.h>
116 #include <QtxFontEdit.h>
117 #include <QtxPopupMgr.h>
118 #include <QtxInfoPanel.h>
119 #include <SALOME_ListIO.hxx>
120 #include <SUIT_Desktop.h>
121 #include <SUIT_FileDlg.h>
122 #include <SUIT_MessageBox.h>
123 #include <SUIT_OverrideCursor.h>
124 #include <SUIT_ResourceMgr.h>
125 #include <SUIT_Session.h>
126 #include <SVTK_Renderer.h>
127 #include <SVTK_ViewManager.h>
128 #include <SVTK_ViewModel.h>
129 #include <SVTK_ViewWindow.h>
130 #include <SalomeApp_Application.h>
131 #include <SalomeApp_CheckFileDlg.h>
132 #include <SalomeApp_DataObject.h>
133 #include <SalomeApp_Study.h>
134 #include <SalomeApp_Tools.h>
135 #include <VTKViewer_Algorithm.h>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
147 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
150 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
151 #include <QApplication>
153 #include <QDialogButtonBox>
157 #include <QTextStream>
161 #include <boost/shared_ptr.hpp>
164 #include <vtkCallbackCommand.h>
165 #include <vtkCamera.h>
166 #include <vtkLookupTable.h>
167 #include <vtkPlane.h>
168 #include <vtkRenderer.h>
170 // SALOME KERNEL includes
171 #include <Basics_Utils.hxx>
172 #include <SALOMEDSClient_ClientFactory.hxx>
173 #include <SALOMEDSClient_IParameters.hxx>
174 #include <SALOMEDSClient_SComponent.hxx>
175 #include <SALOMEDSClient_StudyBuilder.hxx>
176 #include <SALOMEDS_SObject.hxx>
177 #include <SALOMEDS_Study.hxx>
178 #include <SALOME_GenericObj_wrap.hxx>
179 #include <SALOME_LifeCycleCORBA.hxx>
180 #include <utilities.h>
183 #include <Standard_ErrorHandler.hxx>
184 #include <NCollection_DataMap.hxx>
185 #include <NCollection_DoubleMap.hxx>
187 // Below macro, when uncommented, switches on simplified (more performant) algorithm
188 // of auto-color picking up
189 #define SIMPLE_AUTOCOLOR
194 //=============================================================
195 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
198 void ExportMeshToFile(int theCommandID);
200 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
202 void SetDisplayEntity(int theCommandID);
204 int ActionToControl( int theID, bool theReversed = false );
206 void Control( int theCommandID );
209 //================================================================================
211 * \brief Reads meshes from file
213 //================================================================================
215 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
219 std::string myExtension;
221 if ( theCommandID == SMESHOp::OpImportMED ||
222 theCommandID == SMESHOp::OpPopupImportMED ) {
223 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
224 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
226 else if ( theCommandID == SMESHOp::OpImportUNV ||
227 theCommandID == SMESHOp::OpPopupImportUNV ) {
228 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
230 else if ( theCommandID == SMESHOp::OpImportDAT ||
231 theCommandID == SMESHOp::OpPopupImportDAT ) {
232 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
234 else if ( theCommandID == SMESHOp::OpImportSTL ||
235 theCommandID == SMESHOp::OpPopupImportSTL ) {
236 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
238 else if ( theCommandID == SMESHOp::OpImportCGNS ||
239 theCommandID == SMESHOp::OpPopupImportCGNS ) {
240 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
242 else if ( theCommandID == SMESHOp::OpImportSAUV ||
243 theCommandID == SMESHOp::OpPopupImportSAUV ) {
244 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
245 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
247 else if ( theCommandID == SMESHOp::OpImportGMF ||
248 theCommandID == SMESHOp::OpPopupImportGMF ) {
249 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
250 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
253 QString anInitialPath = "";
254 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
255 anInitialPath = QDir::currentPath();
257 QStringList filenames;
258 bool toCreateGroups = true;
260 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
261 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
262 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
263 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
264 // fd->setNameFilters( filter );
265 // fd->SetChecked( true );
267 // filenames << fd->selectedFile();
268 // toCreateGroups = fd->IsChecked();
274 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
277 QObject::tr( "SMESH_IMPORT_MESH" ) );
279 if ( filenames.count() > 0 )
281 SUIT_OverrideCursor wc;
282 _PTR(Study) aStudy = SMESH::getStudy();
285 QStringList anEntryList;
286 bool isEmpty = false;
287 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
289 QString filename = *it;
290 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
292 switch ( theCommandID ) {
293 case SMESHOp::OpImportDAT:
294 case SMESHOp::OpPopupImportDAT:
296 // DAT format (currently unsupported)
297 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
298 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
301 case SMESHOp::OpImportUNV:
302 case SMESHOp::OpPopupImportUNV:
305 aMeshes->length( 1 );
306 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
307 if ( aMeshes[0]->_is_nil() )
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
312 case SMESHOp::OpImportMED:
313 case SMESHOp::OpPopupImportMED:
316 SMESH::DriverMED_ReadStatus res;
317 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
318 if ( res != SMESH::DRS_OK ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
324 case SMESHOp::OpImportSTL:
325 case SMESHOp::OpPopupImportSTL:
328 aMeshes->length( 1 );
329 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
330 if ( aMeshes[0]->_is_nil() ) {
331 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
332 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
336 case SMESHOp::OpImportCGNS:
337 case SMESHOp::OpPopupImportCGNS:
340 SMESH::DriverMED_ReadStatus res;
341 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
342 if ( res != SMESH::DRS_OK ) {
343 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
344 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
348 case SMESHOp::OpImportSAUV:
349 case SMESHOp::OpPopupImportSAUV:
352 SMESH::DriverMED_ReadStatus res;
353 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
354 if ( res != SMESH::DRS_OK ) {
355 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
356 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
360 case SMESHOp::OpImportGMF:
361 case SMESHOp::OpPopupImportGMF:
364 SMESH::ComputeError_var res;
365 aMeshes->length( 1 );
366 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
369 if ( res->code != SMESH::DRS_OK ) {
370 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
371 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
372 if ( strlen( res->comment.in() ) > 0 ) {
373 errors.back() += ": ";
374 errors.back() += res->comment.in();
381 catch ( const SALOME::SALOME_Exception& S_ex ) {
382 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
383 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
386 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
388 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
390 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
391 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
392 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
393 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
394 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
396 anEntryList.append( aMeshSO->GetID().c_str() );
404 // update Object browser
405 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
407 // browse to the published meshes
408 if( LightApp_Application* anApp =
409 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
410 anApp->browseObjects( anEntryList );
412 // show Error message box if there were errors
413 if ( errors.count() > 0 ) {
414 SUIT_MessageBox::critical( SMESHGUI::desktop(),
415 QObject::tr( "SMESH_ERROR" ),
416 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
419 // show warning message box, if some imported mesh is empty
421 SUIT_MessageBox::warning( SMESHGUI::desktop(),
422 QObject::tr( "SMESH_WRN_WARNING" ),
423 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
428 //================================================================================
430 * \brief Export selected meshes or groups into a file
432 //================================================================================
434 void ExportMeshToFile( int theCommandID )
436 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
437 SALOME_ListIO selected;
439 aSel->selectedObjects( selected );
441 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
442 theCommandID == SMESHOp::OpPopupExportDAT );
443 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
444 theCommandID == SMESHOp::OpPopupExportMED );
445 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
446 theCommandID == SMESHOp::OpPopupExportUNV );
447 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
448 theCommandID == SMESHOp::OpPopupExportSTL );
449 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
450 theCommandID == SMESHOp::OpPopupExportCGNS );
451 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
452 theCommandID == SMESHOp::OpPopupExportSAUV );
453 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
454 theCommandID == SMESHOp::OpPopupExportGMF );
456 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
457 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
459 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
460 bool aCheckWarn = true;
462 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
463 // get mesh object from selection and check duplication of their names
464 bool hasDuplicatedMeshNames = false;
465 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
466 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
467 SALOME_ListIteratorOfListIO It( selected );
468 for( ; It.More(); It.Next() )
470 Handle(SALOME_InteractiveObject) anIObject = It.Value();
471 SMESH::SMESH_IDSource_var aMeshItem =
472 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
473 if ( aMeshItem->_is_nil() ) {
474 SUIT_MessageBox::warning( SMESHGUI::desktop(),
475 QObject::tr( "SMESH_WRN_WARNING" ),
476 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
479 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
480 if ( aCheckWarn && !aGroup->_is_nil() )
482 QMessageBox msgBox(SUIT_MessageBox::Warning,
483 QObject::tr("SMESH_WRN_WARNING"),
484 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
485 QMessageBox::StandardButton::NoButton,
486 SMESHGUI::desktop());
487 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
488 msgBox.addButton(QMessageBox::Ok);
489 msgBox.addButton(QMessageBox::Cancel);
490 msgBox.setDefaultButton(QMessageBox::Cancel);
491 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
492 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
493 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
494 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
495 if ( msgBox.exec() != QMessageBox::Ok )
498 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
499 resMgr->setValue( "SMESH", "show_warning", false);
502 QString aMeshName = anIObject->getName();
504 // check for name duplications
505 if ( !hasDuplicatedMeshNames )
506 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
507 if( aMeshName == (*aMeshIter).second ) {
508 hasDuplicatedMeshNames = true;
513 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
516 if( hasDuplicatedMeshNames && isMED ) {
517 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
518 QObject::tr("SMESH_WRN_WARNING"),
519 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
520 QObject::tr("SMESH_BUT_YES"),
521 QObject::tr("SMESH_BUT_NO"), 0, 1);
526 aMeshIter = aMeshList.begin();
527 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
528 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
529 QString aMeshName = (*aMeshIter).second;
531 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
533 // check for equal group names within each mesh
534 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
535 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
536 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
537 int aRet = SUIT_MessageBox::warning
538 (SMESHGUI::desktop(),
539 QObject::tr("SMESH_WRN_WARNING"),
540 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
541 QObject::tr("SMESH_BUT_YES"),
542 QObject::tr("SMESH_BUT_NO"), 0, 1);
549 // Warn the user about presence of not supported elements
551 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
555 notSupportedElemTypes.push_back( SMESH::Entity_0D );
556 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
561 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
562 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
563 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
564 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
565 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
566 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
567 notSupportedElemTypes.push_back( SMESH::Entity_0D );
568 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
573 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
574 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
575 notSupportedElemTypes.push_back( SMESH::Entity_0D );
576 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
581 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
586 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
587 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
588 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
589 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
590 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
591 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
592 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
593 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
598 notSupportedElemTypes.push_back( SMESH::Entity_0D );
599 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
600 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
601 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
602 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
603 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
604 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
605 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
606 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
607 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
609 if ( ! notSupportedElemTypes.empty() )
611 SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
612 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
613 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
614 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
616 if ( !presentNotSupported.empty() )
619 const char* typeMsg[] = {
620 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
621 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
622 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
623 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
624 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
625 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
626 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
627 "SMESH_BIQUADRATIC_PENTAHEDRONS",
628 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
630 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
631 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
632 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
634 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
635 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
636 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
637 if ( iType != presentNotSupported.size() - 1 )
638 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
640 int aRet = SUIT_MessageBox::warning
641 (SMESHGUI::desktop(),
642 QObject::tr("SMESH_WRN_WARNING"),
643 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
644 QObject::tr("SMESH_BUT_YES"),
645 QObject::tr("SMESH_BUT_NO"), 0, 1);
650 // Get parameters of export operation
653 int aFormat =-1; // for MED version used for write
654 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
656 // Init the parameters with the default values
657 bool aIsASCII_STL = true;
658 bool toCreateGroups = false;
660 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
661 bool toOverwrite = true;
662 bool toFindOutDim = true;
663 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
665 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
666 QString anInitialPath = "";
667 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
668 anInitialPath = QDir::currentPath();
670 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
672 // Get a file name to write in and additional options
673 if ( isUNV || isDAT || isGMF ) // Export w/o options
676 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
678 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
680 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
681 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
682 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
683 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
684 anInitialPath + QString("/") + aMeshName,
685 aFilter, aTitle, false);
687 else if ( isCGNS )// Export to CGNS
689 const char* theByTypeResource = "cgns_group_elems_by_type";
690 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
692 QStringList checkBoxes;
693 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
695 SalomeApp_CheckFileDlg* fd =
696 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
697 fd->setWindowTitle( aTitle );
698 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
699 if ( !anInitialPath.isEmpty() )
700 fd->setDirectory( anInitialPath );
701 fd->selectFile(aMeshName);
702 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
703 fd->setValidator( fv );
704 fd->SetChecked( toCreateGroups, 0 );
707 aFilename = fd->selectedFile();
708 toOverwrite = fv->isOverwrite(aFilename);
709 toCreateGroups = fd->IsChecked(0);
710 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
714 else if ( isSTL ) // Export to STL
716 QMap<QString, int> aFilterMap;
717 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
718 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
721 QMap<QString, int>::const_iterator it = aFilterMap.begin();
722 for ( ; it != aFilterMap.end(); ++it )
723 filters.push_back( it.key() );
725 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
726 fd->setWindowTitle( aTitle );
727 fd->setNameFilters( filters );
728 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
729 if ( !anInitialPath.isEmpty() )
730 fd->setDirectory( anInitialPath );
731 fd->selectFile(aMeshName);
735 aFilename = fd->selectedFile();
736 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
741 else if ( isMED || isSAUV ) // Export to MED or SAUV
743 int defaultVersion = 0;
744 QMap<QString, int> aFilterMap;
746 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
747 //QString vmed (aMesh->GetVersionString(-1, 2));
748 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
749 if ( mvok->length() > 0)
750 defaultVersion = mvok[0]; // the current version to set the default filter on it
751 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
753 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
754 MESSAGE("MED version: " << vs.toStdString());
755 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
759 aFilterMap.insert("All files (*)", -1 );
760 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
761 aFilterMap.insert("SAUV files (*.sauve)", -1 );
764 QMap<QString, int>::const_iterator it = aFilterMap.begin();
765 QString aDefaultFilter = it.key();
766 for ( ; it != aFilterMap.end(); ++it ) {
767 filters.push_back( it.key() );
768 if (it.value() == defaultVersion) // explicit default for MED = current MED version
769 aDefaultFilter = it.key();
771 QStringList checkBoxes;
772 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
774 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
775 QList< QWidget* > wdgList;
776 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
777 wdgList.append( fieldSelWdg );
779 QWidget* zTolWdg = new QWidget();
780 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
781 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
782 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
783 zTolLayout->addWidget( zTolCheck );
784 zTolLayout->addWidget( zTolSpin );
785 zTolLayout->setMargin( 0 );
786 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
787 zTolSpin->setValue( zTol );
788 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
789 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
790 zTolSpin ->setEnabled( zTolCheck->isChecked() );
791 wdgList.append( zTolWdg );
793 SalomeApp_CheckFileDlg* fd =
794 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
795 fd->setWindowTitle( aTitle );
796 fd->setNameFilters( filters );
797 fd->selectNameFilter( aDefaultFilter );
798 fd->SetChecked( toCreateGroups, 0 );
799 fd->SetChecked( toFindOutDim, 1 );
800 if ( !anInitialPath.isEmpty() )
801 fd->setDirectory( anInitialPath );
802 fd->selectFile(aMeshName);
805 QListView *lview = fd->findChild<QListView*>("listView");
807 lview->setMinimumHeight(200);
809 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
811 tview->setMinimumHeight(200);
814 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
815 fd->setValidator( fv );
820 //MESSAGE("******* Loop on file dialog ***********");
823 aFilename = fd->selectedFile();
825 aFilename = QString::null;
828 aFormat = aFilterMap[fd->selectedNameFilter()];
829 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
830 toOverwrite = fv->isOverwrite(aFilename);
831 //MESSAGE("toOverwrite:" << toOverwrite);
833 if ( !aFilename.isEmpty() ) {
835 // append is only possible if the existing file format is compatible
836 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
837 MESSAGE("Append check, isVersionOk:" << isVersionOk);
838 if ( !isVersionOk ) {
839 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
840 QObject::tr("SMESH_WRN_WARNING"),
841 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
842 QObject::tr("SMESH_BUT_YES"),
843 QObject::tr("SMESH_BUT_NO"), 0, 1);
847 //MESSAGE("incompatible MED file version for add, overwrite accepted");
853 //MESSAGE("incompatible MED file version for add, overwrite refused");
856 QStringList aMeshNamesCollisionList;
857 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
858 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
859 QString anExistingMeshName( aMeshNames[ i ] );
860 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
861 QString anExportMeshName = (*aMeshIter).second;
862 if( anExportMeshName == anExistingMeshName ) {
863 aMeshNamesCollisionList.append( anExportMeshName );
868 if( !aMeshNamesCollisionList.isEmpty() ) {
870 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
871 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
872 QObject::tr("SMESH_WRN_WARNING"),
873 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
874 QObject::tr("SMESH_BUT_YES"),
875 QObject::tr("SMESH_BUT_NO"),
876 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
877 MESSAGE("answer collision name " << aRet);
888 toCreateGroups = fd->IsChecked(0);
889 toFindOutDim = fd->IsChecked(1);
890 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
891 fieldSelWdg->GetSelectedFields();
892 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
894 if ( !fieldSelWdg->parent() )
896 if ( !zTolWdg->parent() )
907 if ( !aFilename.isEmpty() ) {
908 // Check whether the file already exists and delete it if yes
909 QFile aFile( aFilename );
910 if ( aFile.exists() && toOverwrite )
912 SUIT_OverrideCursor wc;
915 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
916 // bool Renumber = false;
917 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
919 // Renumber= resMgr->booleanValue("renumbering");
921 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
922 // aMeshEditor->RenumberNodes();
923 // aMeshEditor->RenumberElements();
924 // if ( SMESHGUI::automaticUpdate() )
925 // SMESH::UpdateView();
927 if ( isMED && isOkToWrite)
929 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
930 aMeshIter = aMeshList.begin();
931 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
933 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
934 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
935 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
936 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
937 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
938 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
939 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
940 toOverwrite && aMeshIndex == 0, toFindOutDim );
942 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
943 toCreateGroups, aFormat,
944 toOverwrite && aMeshIndex == 0, toFindOutDim,
945 fields, geoAssFields.toLatin1().data(), zTol );
950 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
952 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
953 if( !aMeshItem->_is_nil() )
954 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
959 if ( aMeshOrGroup->_is_equivalent( aMesh ))
960 aMesh->ExportDAT( aFilename.toUtf8().data() );
962 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
966 if ( aMeshOrGroup->_is_equivalent( aMesh ))
967 aMesh->ExportUNV( aFilename.toUtf8().data() );
969 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
973 if ( aMeshOrGroup->_is_equivalent( aMesh ))
974 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
976 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
980 aMeshIter = aMeshList.begin();
981 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
983 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
984 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
985 aMeshItem->ExportCGNS( aMeshOrGroup,
986 aFilename.toUtf8().data(),
987 toOverwrite && aMeshIndex == 0,
993 toCreateGroups = true;
994 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
997 catch (const SALOME::SALOME_Exception& S_ex)
1000 if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
1001 strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
1003 SUIT_MessageBox::critical(SMESHGUI::desktop(),
1004 QObject::tr("SMESH_WRN_WARNING"),
1005 QObject::tr(S_ex.details.text.in() ));
1007 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1008 QObject::tr("SMESH_WRN_WARNING"),
1009 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1015 inline void InverseEntityMode(unsigned int& theOutputMode,
1016 unsigned int theMode)
1018 bool anIsNotPresent = ~theOutputMode & theMode;
1020 theOutputMode |= theMode;
1022 theOutputMode &= ~theMode;
1025 void SetDisplayEntity(int theCommandID)
1027 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1028 SALOME_ListIO selected;
1030 aSel->selectedObjects( selected );
1032 if ( selected.Extent() >= 1 ) {
1033 SUIT_OverrideCursor wc;
1034 SALOME_ListIteratorOfListIO It( selected );
1035 for( ; It.More(); It.Next()){
1036 Handle(SALOME_InteractiveObject) IObject = It.Value();
1037 if(IObject->hasEntry()){
1038 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1039 unsigned int aMode = anActor->GetEntityMode();
1040 switch(theCommandID){
1041 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1042 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1043 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1044 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1045 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1046 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1049 anActor->SetEntityMode(aMode);
1058 SalomeApp_Application* app =
1059 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1063 LightApp_SelectionMgr* aSel = app->selectionMgr();
1064 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1065 if ( !aSel || !appStudy )
1068 SALOME_ListIO selected;
1069 aSel->selectedObjects( selected );
1070 if ( selected.IsEmpty() )
1073 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1075 _PTR(Study) aStudy = appStudy->studyDS();
1076 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1077 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1078 if ( aMainObject->_is_nil() )
1081 SUIT_OverrideCursor wc;
1083 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1085 QList<SALOMEDS::Color> aReservedColors;
1087 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1088 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1090 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1092 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1093 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1094 #else // old algorithm for auto-colors
1095 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1096 aReservedColors.append( aColor );
1097 #endif // SIMPLE_AUTOCOLOR
1098 aGroupObject->SetColor( aColor );
1100 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1101 if ( aGroupSObject ) {
1104 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1105 switch ( aGroupObject->GetType ()) {
1107 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1109 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1111 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1113 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1115 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1116 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1119 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1120 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1126 SMESH::RepaintCurrentView();
1129 void OverallMeshQuality()
1131 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1132 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1133 SALOME_ListIO selected;
1135 aSel->selectedObjects( selected );
1137 if ( selected.IsEmpty() ) return;
1138 SALOME_ListIteratorOfListIO It( selected );
1139 for ( ; It.More(); It.Next() ) {
1140 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1141 ctrlDlg->showInfo( It.Value() );
1146 QString functorToString( SMESH::Controls::FunctorPtr f )
1148 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1149 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1150 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1151 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1152 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1153 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1154 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1155 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1156 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1157 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1158 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1159 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1160 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1161 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1162 type = QObject::tr( "WARP_ELEMENTS" );
1163 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1164 type = QObject::tr( "TAPER_ELEMENTS" );
1165 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1166 type = QObject::tr( "SKEW_ELEMENTS" );
1167 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1168 type = QObject::tr( "AREA_ELEMENTS" );
1169 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1170 type = QObject::tr( "LENGTH_EDGES" );
1171 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1172 type = QObject::tr( "LENGTH2D_EDGES" );
1173 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1174 type = QObject::tr( "DEFLECTION2D_FACES" );
1175 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1176 type = QObject::tr( "MULTI_BORDERS" );
1177 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1178 type = QObject::tr( "MULTI2D_BORDERS" );
1179 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1180 type = QObject::tr( "FREE_NODES" );
1181 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1182 type = QObject::tr( "FREE_EDGES" );
1183 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1184 type = QObject::tr( "FREE_BORDERS" );
1185 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1186 type = QObject::tr( "FREE_FACES" );
1187 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1188 type = QObject::tr( "BARE_BORDER_VOLUME" );
1189 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1190 type = QObject::tr( "BARE_BORDER_FACE" );
1191 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1192 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1193 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1194 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1195 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1196 type = QObject::tr( "EQUAL_NODE" );
1197 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1198 type = QObject::tr( "EQUAL_EDGE" );
1199 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1200 type = QObject::tr( "EQUAL_FACE" );
1201 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1202 type = QObject::tr( "EQUAL_VOLUME" );
1203 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1204 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1208 void SaveDistribution()
1210 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1211 SALOME_ListIO selected;
1213 aSel->selectedObjects( selected );
1215 if ( selected.Extent() == 1 ) {
1216 Handle(SALOME_InteractiveObject) anIO = selected.First();
1217 if ( anIO->hasEntry() ) {
1218 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1220 anActor->GetScalarBarActor() &&
1221 anActor->GetControlMode() != SMESH_Actor::eNone )
1223 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1224 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1225 if ( aScalarBarActor && aFunctor ) {
1226 SMESH::Controls::NumericalFunctor* aNumFun =
1227 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1229 std::vector<smIdType> elements;
1230 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1231 if ( mesh->_is_nil() ) {
1232 SMESH::SMESH_IDSource_var idSource =
1233 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1234 if ( !idSource->_is_nil() )
1236 SMESH::smIdType_array_var ids = idSource->GetIDs();
1237 elements.resize( ids->length() );
1238 for ( unsigned i = 0; i < elements.size(); ++i )
1239 elements[i] = ids[i];
1242 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1243 vtkLookupTable* lookupTable =
1244 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1245 double * minmax = lookupTable->GetRange();
1246 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1247 std::vector<int> nbEvents;
1248 std::vector<double> funValues;
1249 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1250 elements, minmax, isLogarithmic );
1251 QString anInitialPath = "";
1252 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1253 anInitialPath = QDir::currentPath();
1254 QString aMeshName = anIO->getName();
1256 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1257 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1258 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1259 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1260 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1263 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1265 if ( !aFilename.isEmpty() ) {
1266 QFile f( aFilename );
1267 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1268 QTextStream out( &f );
1269 out << "# Mesh: " << aMeshName << endl;
1270 out << "# Control: " << functorToString( aFunctor ) << endl;
1272 out.setFieldWidth( 10 );
1273 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1274 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1285 void ShowElement( int theCommandID )
1287 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1288 SALOME_ListIO selected;
1290 aSel->selectedObjects( selected );
1292 if ( selected.Extent() == 1 ) {
1293 Handle(SALOME_InteractiveObject) anIO = selected.First();
1294 if ( anIO->hasEntry() ) {
1295 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1297 anActor->GetScalarBarActor() &&
1298 anActor->GetControlMode() != SMESH_Actor::eNone )
1300 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1301 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1302 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1304 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1305 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1312 #ifndef DISABLE_PLOT2DVIEWER
1313 void PlotDistribution()
1315 SalomeApp_Application* app =
1316 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1320 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1321 SALOME_ListIO selected;
1323 aSel->selectedObjects( selected );
1325 if ( selected.Extent() == 1 ) {
1326 Handle(SALOME_InteractiveObject) anIO = selected.First();
1327 if ( anIO->hasEntry() ) {
1328 //Find Actor by entry before getting Plot2d viewer,
1329 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1330 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1332 SUIT_ViewManager* aViewManager =
1333 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1337 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1341 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1345 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1347 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1348 QString functorName = functorToString( anActor->GetFunctor());
1349 QString aHistogramName("%1 : %2");
1350 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1351 aHistogram->setName(aHistogramName);
1352 aHistogram->setHorTitle(functorName);
1353 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1354 aPlot->displayObject(aHistogram, true);
1359 #endif //DISABLE_PLOT2DVIEWER
1361 void DisableAutoColor()
1363 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1364 SALOME_ListIO selected;
1366 aSel->selectedObjects( selected );
1368 if ( selected.Extent() ) {
1369 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1370 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1371 if ( !aMesh->_is_nil() ) {
1372 aMesh->SetAutoColor( false );
1379 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1380 SALOME_ListIO selected;
1382 aSel->selectedObjects( selected );
1383 if ( selected.Extent() )
1385 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1386 _PTR(Study) aStudy = SMESH::getStudy();
1387 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1389 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1390 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1397 // Break link with Shaper model
1398 void breakShaperLink()
1400 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1401 SALOME_ListIO selected;
1403 aSel->selectedObjects(selected);
1404 if (selected.Extent()) {
1405 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1406 _PTR(Study) aStudy = SMESH::getStudy();
1407 std::string aEntry = anIObject->getEntry();
1408 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1410 std::string aName = aSObj->GetName();
1411 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1412 QObject::tr("SMESH_WRN_WARNING"),
1413 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1414 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1415 if (aRes == SUIT_MessageBox::Yes) {
1416 SUIT_DataOwnerPtrList aList;
1417 aSel->selected(aList, "ObjectBrowser", true);
1418 SUIT_DataOwner* aOwn = aList.first();
1419 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1420 QString aREntry = sowner->entry();
1422 static GEOM::GEOM_Gen_var geomGen;
1423 if (CORBA::is_nil(geomGen)) {
1424 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1425 (SUIT_Session::session()->activeApplication());
1427 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1428 Engines::EngineComponent_var comp =
1429 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1430 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1433 if (!CORBA::is_nil(geomGen))
1435 geomGen->BreakLink(aREntry.toStdString().c_str());
1436 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1438 // remove actors whose objects are removed by BreakLink()
1439 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1440 SUIT_ViewWindow* wnd;
1441 foreach(wnd, wndList)
1442 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1450 //================================================================================
1452 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1453 * which means that the mesh can't be modified. It should be either re-computed
1454 * or breakShaperLink()'ed. Warn the user about it.
1456 //================================================================================
1458 bool warnOnGeomModif()
1460 SALOME_ListIO selected;
1461 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1462 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1464 SALOME_ListIteratorOfListIO It( selected );
1465 for ( ; It.More(); It.Next() )
1467 Handle(SALOME_InteractiveObject) io = It.Value();
1468 if ( !io->hasEntry() ) continue;
1469 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1470 SMESH::SMESH_Mesh_var mesh;
1471 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1473 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1474 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1475 if ( isrc->_is_nil() )
1476 so = so->GetFather();
1478 mesh = isrc->GetMesh();
1480 if ( mesh->_is_nil() ) continue;
1481 so = SMESH::FindSObject( mesh );
1482 if ( !so ) continue;
1483 _PTR(GenericAttribute) attr;
1484 so->FindAttribute( attr, "AttributePixMap" );
1485 _PTR(AttributePixMap) pixmap = attr;
1486 if ( !pixmap ) continue;
1488 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1490 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1491 QObject::tr("SMESH_WRN_WARNING"),
1492 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1499 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1501 SALOME_ListIO selected;
1502 SalomeApp_Application* app =
1503 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1507 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1508 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1509 if ( !aSel || !appStudy )
1512 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1513 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1514 aModule->EmitSignalDeactivateDialog();
1515 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1516 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1521 aSel->selectedObjects( selected );
1523 if ( selected.Extent() >= 1 )
1525 switch ( theCommandID ) {
1526 case SMESHOp::OpTransparency:
1528 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1529 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1532 case SMESHOp::OpProperties:
1535 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1536 QColor orientationColor, outlineColor, volumeColor;
1537 int deltaF = 0, deltaV = 0;
1540 double ballScale = 1.0;
1542 int outlineWidth = 1;
1543 double shrinkCoef = 0.0;
1544 double orientationScale = 0.0;
1545 bool orientation3d = false;
1546 VTK::MarkerType markerType = VTK::MT_NONE;
1547 VTK::MarkerScale markerScale = VTK::MS_NONE;
1549 bool hasNodes = false;
1550 int presentEntities = 0;
1551 bool firstTime = true;
1553 SALOME_ListIteratorOfListIO It( selected );
1554 for ( ; It.More(); It.Next() ) {
1555 Handle(SALOME_InteractiveObject) IObject = It.Value();
1556 if ( !IObject->hasEntry() ) continue;
1557 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1558 if ( !anActor || !anActor->GetObject() ) continue;
1561 // nodes: color, marker
1562 anActor->GetNodeColor( color[0], color[1], color[2] );
1563 nodeColor.setRgbF( color[0], color[1], color[2] );
1564 markerType = anActor->GetMarkerType();
1565 markerScale = anActor->GetMarkerScale();
1566 markerId = anActor->GetMarkerTexture();
1567 // edges: color, width
1568 anActor->GetEdgeColor( color[0], color[1], color[2] );
1569 edgeColor.setRgbF( color[0], color[1], color[2] );
1570 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1571 // faces: front color, back color (delta)
1572 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1573 faceColor.setRgbF( color[0], color[1], color[2] );
1574 // faces: front color, back color (delta)
1575 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1576 volumeColor.setRgbF( color[0], color[1], color[2] );
1577 // 0d elements: color, size
1578 anActor->Get0DColor( color[0], color[1], color[2] );
1579 elem0dColor.setRgbF( color[0], color[1], color[2] );
1580 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1581 // balls: color, size
1582 anActor->GetBallColor( color[0], color[1], color[2] );
1583 ballColor.setRgbF( color[0], color[1], color[2] );
1584 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1585 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1587 anActor->GetOutlineColor( color[0], color[1], color[2] );
1588 outlineColor.setRgbF( color[0], color[1], color[2] );
1589 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1590 // orientation vectors: color, scale, 3d flag
1591 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1592 orientationColor.setRgbF( color[0], color[1], color[2] );
1593 orientationScale = anActor->GetFacesOrientationScale();
1594 orientation3d = anActor->GetFacesOrientation3DVectors();
1596 shrinkCoef = anActor->GetShrinkFactor();
1599 firstTime = false; // we only take properties from first object (for performance reasons)
1602 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1603 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1604 presentEntities = presentEntities | SMESH_Actor::eEdges;
1605 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1606 presentEntities = presentEntities | SMESH_Actor::eFaces;
1607 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1608 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1609 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1610 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1611 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1612 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1614 // as we know that all types of elements are present, we can exit the loop
1615 if ( presentEntities == SMESH_Actor::eAllEntity )
1619 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1620 // nodes: color, marker
1621 dlg.setNodeColor( nodeColor );
1622 if( markerType != VTK::MT_USER )
1623 dlg.setNodeMarker( markerType, markerScale );
1625 dlg.setNodeCustomMarker( markerId );
1626 // edges: color, line width
1627 dlg.setEdgeColor( edgeColor );
1628 dlg.setEdgeWidth( edgeWidth );
1629 // faces: front color, back color
1630 dlg.setFaceColor( faceColor, deltaF );
1631 // volumes: normal color, reversed color
1632 dlg.setVolumeColor( volumeColor, deltaV );
1633 // outlines: color, line width
1634 dlg.setOutlineColor( outlineColor );
1635 dlg.setOutlineWidth( outlineWidth );
1636 // 0d elements: color, size
1637 dlg.setElem0dColor( elem0dColor );
1638 dlg.setElem0dSize( elem0dSize );
1639 // balls: color, size
1640 dlg.setBallColor( ballColor );
1641 //dlg.setBallSize( ballSize );
1642 dlg.setBallScale( ballScale );
1643 // orientation: color, scale, 3d flag
1644 dlg.setOrientationColor( orientationColor );
1645 dlg.setOrientationSize( int( orientationScale * 100. ) );
1646 dlg.setOrientation3d( orientation3d );
1647 // shrink: scale factor
1648 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1649 // hide unused controls
1650 dlg.showControls( presentEntities, hasNodes );
1653 nodeColor = dlg.nodeColor();
1654 markerType = dlg.nodeMarkerType();
1655 markerScale = dlg.nodeMarkerScale();
1656 markerId = dlg.nodeMarkerId();
1657 edgeColor = dlg.edgeColor();
1658 edgeWidth = dlg.edgeWidth();
1659 faceColor = dlg.faceColor();
1660 deltaF = dlg.faceColorDelta();
1661 volumeColor = dlg.volumeColor();
1662 deltaV = dlg.volumeColorDelta();
1663 outlineColor = dlg.outlineColor();
1664 outlineWidth = dlg.outlineWidth();
1665 elem0dColor = dlg.elem0dColor();
1666 elem0dSize = dlg.elem0dSize();
1667 ballColor = dlg.ballColor();
1668 // ballSize = dlg.ballSize();
1669 ballScale = dlg.ballScale();
1670 orientationColor = dlg.orientationColor();
1671 orientationScale = dlg.orientationSize() / 100.;
1672 orientation3d = dlg.orientation3d();
1673 shrinkCoef = dlg.shrinkCoef() / 100.;
1675 // store point markers that might be changed by the user
1676 theMarkerMap = dlg.customMarkers();
1678 // set properties from dialog box to the presentations
1679 SALOME_ListIteratorOfListIO It( selected );
1680 for ( ; It.More(); It.Next() ) {
1681 Handle(SALOME_InteractiveObject) IObject = It.Value();
1682 if ( !IObject->hasEntry() ) continue;
1683 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1684 if ( !anActor ) continue;
1686 // nodes: color, marker
1687 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1688 if ( markerType != VTK::MT_USER ) {
1689 anActor->SetMarkerStd( markerType, markerScale );
1692 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1693 if ( iter != theMarkerMap.end() )
1694 anActor->SetMarkerTexture( markerId, iter->second.second );
1696 // volumes: normal color, reversed color (delta)
1697 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1698 // faces: front color, back color (delta)
1699 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1700 // edges: color, width
1701 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1702 anActor->SetLineWidth( edgeWidth );
1704 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1705 anActor->SetOutlineWidth( outlineWidth );
1706 // 0D elements: color, size
1707 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1708 anActor->Set0DSize( elem0dSize );
1709 // balls: color, size
1710 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1711 // anActor->SetBallSize( ballSize );
1712 anActor->SetBallScale( ballScale );
1713 // orientation: color, scale, 3d flag
1714 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1715 anActor->SetFacesOrientationScale( orientationScale );
1716 anActor->SetFacesOrientation3DVectors( orientation3d );
1718 anActor->SetShrinkFactor( shrinkCoef );
1720 // for groups, set also proper color
1721 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1722 if ( !aGroupObject->_is_nil() ) {
1723 SMESH::ElementType anElementType = aGroupObject->GetType();
1725 switch( anElementType ) {
1727 aColor = nodeColor; break;
1729 aColor = edgeColor; break;
1731 aColor = faceColor; break;
1733 aColor = volumeColor; break;
1735 aColor = elem0dColor; break;
1737 aColor = ballColor; break;
1741 if ( aColor.isValid() ) {
1742 SALOMEDS::Color aGroupColor;
1743 aGroupColor.R = aColor.redF();
1744 aGroupColor.G = aColor.greenF();
1745 aGroupColor.B = aColor.blueF();
1746 aGroupObject->SetColor( aGroupColor );
1748 } // if ( !aGroupObject->_is_nil() )
1749 } // for ( ; It.More(); It.Next() )
1750 SMESH::RepaintCurrentView();
1751 } // if ( dlg.exec() )
1753 } // case SMESHOp::OpProperties:
1754 } // switch(theCommandID)
1755 SUIT_OverrideCursor wc;
1756 SALOME_ListIteratorOfListIO It( selected );
1757 for( ; It.More(); It.Next()){
1758 Handle(SALOME_InteractiveObject) IObject = It.Value();
1759 if(IObject->hasEntry()){
1760 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1761 switch(theCommandID){
1762 case SMESHOp::OpDMWireframe:
1763 anActor->SetRepresentation(SMESH_Actor::eEdge);
1765 case SMESHOp::OpDMShading:
1766 anActor->SetRepresentation(SMESH_Actor::eSurface);
1768 case SMESHOp::OpDMShrink:
1769 if(anActor->IsShrunk())
1770 anActor->UnShrink();
1772 anActor->SetShrink();
1774 case SMESHOp::OpDMNodes:
1775 anActor->SetRepresentation(SMESH_Actor::ePoint);
1777 case SMESHOp::OpRepresentationLines:
1778 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1779 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1781 case SMESHOp::OpRepresentationArcs:
1782 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1783 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1789 SMESH::RepaintCurrentView();
1793 int ActionToControl( int theID, bool theReversed )
1795 NCollection_DoubleMap<int,int> ActionControl;
1796 ActionControl.Bind( 0, SMESH_Actor::eNone );
1797 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1798 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1799 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1800 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1801 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1802 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1803 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1804 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1805 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1806 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1807 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1808 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1809 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1810 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1811 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1812 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1813 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1814 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1815 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1816 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1817 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1818 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1819 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1820 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1821 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1822 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1823 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1824 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1827 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1828 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1831 void Control( int theCommandID )
1833 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1834 _PTR(Study) aStudy = SMESH::getStudy();
1836 SALOME_ListIO selected;
1837 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1838 aSel->selectedObjects( selected );
1840 if ( !selected.IsEmpty() ) {
1841 SALOME_ListIteratorOfListIO It(selected);
1842 for ( ; It.More(); It.Next())
1844 Handle(SALOME_InteractiveObject) anIO = It.Value();
1845 if ( !anIO.IsNull() ) {
1846 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1848 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1849 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1850 if ( !anIDSrc->_is_nil() ) {
1851 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1852 if (( !anActor && selected.Extent() == 1 ) &&
1853 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1855 anActor->SetControlMode( aControl );
1856 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1857 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1861 if ( anActor->GetControlMode() != aControl )
1862 anActor->SetControlMode( aControl );
1863 QString functorName = functorToString( anActor->GetFunctor() );
1864 smIdType anEntitiesCount = anActor->GetNumberControlEntities();
1865 if (anEntitiesCount >= 0)
1866 functorName = functorName + ": " + QString::number(anEntitiesCount);
1867 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1868 SMESH::RepaintCurrentView();
1869 #ifndef DISABLE_PLOT2DVIEWER
1870 if ( anActor->GetPlot2Histogram() ) {
1871 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1872 QString aHistogramName("%1 : %2");
1873 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1874 aHistogram->setName( aHistogramName );
1875 aHistogram->setHorTitle( functorName );
1876 SMESH::ProcessIn2DViewers( anActor );
1888 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1889 SMESH::MeshObjectType theType,
1890 const QString theInTypeName,
1891 QString & theOutTypeName)
1893 SMESH_TypeFilter aTypeFilter( theType );
1895 if ( !theIO.IsNull() )
1897 entry = theIO->getEntry();
1898 LightApp_DataOwner owner( entry );
1899 if ( aTypeFilter.isOk( &owner )) {
1900 theOutTypeName = theInTypeName;
1908 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1910 _PTR(Study) aStudy = SMESH::getStudy();
1911 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1913 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1914 CORBA::String_var anID = aSComp->GetID().c_str();
1915 if ( !strcmp(anID.in(),theIO->getEntry()) )
1921 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1922 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1923 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1924 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1925 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1933 // QString CheckHomogeneousSelection()
1935 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1936 // SALOME_ListIO selected;
1938 // aSel->selectedObjects( selected );
1940 // QString RefType = CheckTypeObject(selected.First());
1941 // SALOME_ListIteratorOfListIO It(selected);
1942 // for ( ; It.More(); It.Next())
1944 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1945 // QString Type = CheckTypeObject(IObject);
1946 // if ( Type.compare(RefType) != 0 )
1947 // return "Heterogeneous Selection";
1953 uint randomize( uint size )
1955 static bool initialized = false;
1956 if ( !initialized ) {
1957 qsrand( QDateTime::currentDateTime().toTime_t() );
1961 v = uint( (double)( v ) / RAND_MAX * size );
1962 v = qMax( uint(0), qMin ( v, size-1 ) );
1968 void SMESHGUI::OnEditDelete()
1970 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1971 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1972 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1974 _PTR(Study) aStudy = SMESH::getStudy();
1975 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1976 _PTR(GenericAttribute) anAttr;
1977 _PTR(AttributeIOR) anIOR;
1979 const int objectCountLimit = 30; // PAL23599
1980 int objectCount = 0;
1982 QString aParentComponent = QString::null;
1984 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1986 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1987 if ( anIO.IsNull() ) continue;
1989 QString father = "unknown", name;
1991 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1993 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1994 // check if object is reference
1995 _PTR(SObject) aRefSObj;
1996 if ( aSO->ReferencedObject( aRefSObj ) ) {
1997 name = QString::fromStdString ( aRefSObj->GetName() );
1998 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
2001 name = anIO->getName();
2004 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
2005 aNameList.append("\n - ");
2006 aNameList.append( name );
2009 if( aParentComponent.isNull() )
2010 aParentComponent = father;
2011 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2012 aParentComponent = "";
2014 if ( objectCount >= objectCountLimit )
2015 aNameList.append("\n - ...");
2017 if ( objectCount == 0 )
2018 return; // No Valid Objects Selected
2020 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2021 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2022 QObject::tr("ERR_ERROR"),
2023 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2026 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2027 if (SUIT_MessageBox::warning
2028 (SMESHGUI::desktop(),
2029 QObject::tr("SMESH_WRN_WARNING"),
2030 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2031 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2032 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2035 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2037 // Put one level of sub-objects of the selected SO's into a list
2038 // in order to get objects inside folders like "Assigned Algorithms"
2039 std::list< _PTR(SObject) > listSO;
2040 SALOME_ListIteratorOfListIO It(selected);
2041 for( ; It.More(); It.Next()) // loop on selected IO's
2043 Handle(SALOME_InteractiveObject) IObject = It.Value();
2044 if(IObject->hasEntry()) {
2045 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2047 // disable removal of "SMESH" component object
2048 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2050 if ( engineIOR() == anIOR->Value().c_str() )
2053 //Check the referenced object
2054 _PTR(SObject) aRefSObject;
2055 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2056 aSO = aRefSObject; // Delete main Object instead of reference
2058 listSO.push_back( aSO );
2060 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2061 for (it->InitEx(false); it->More(); it->Next())
2062 listSO.push_back( it->Value() );
2065 // Check if none of objects to delete is referred from outside
2066 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2067 std::vector< _PTR(SObject) > subSO;
2068 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2070 _PTR(SObject) SO = *ritSO;
2071 if ( !SO ) continue;
2073 int nbChildren = SO->GetLastChildTag();
2075 subSO.reserve( 1 + nbChildren );
2076 subSO.push_back( SO );
2077 if ( nbChildren > 0 )
2079 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2080 for ( it->InitEx( true ); it->More(); it->Next() )
2081 subSO.push_back( it->Value() );
2083 for ( size_t i = 0; i < subSO.size(); ++i )
2085 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2086 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2087 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2088 std::string type = aComponent->ComponentDataType();
2089 if ( type != "SMESH" )
2091 SUIT_MessageBox::warning( anApp->desktop(),
2092 QObject::tr("WRN_WARNING"),
2093 QObject::tr("DEP_OBJECT") );
2094 return; // outside SMESH, there is an object depending on a SMESH object
2100 // Treat SO's in the list starting from the back
2101 aStudyBuilder->NewCommand(); // There is a transaction
2102 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2104 _PTR(SObject) SO = *ritSO;
2105 if ( !SO ) continue;
2106 std::string anEntry = SO->GetID();
2108 /** Erase graphical object and remove all its data **/
2109 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2110 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2112 /** Remove an object from data structures **/
2113 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2114 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2115 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2116 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2117 aMesh->RemoveGroup( aGroup );
2119 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2120 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2121 aMesh->RemoveSubMesh( aSubMesh );
2124 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2125 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2126 QString objType = CheckTypeObject(IObject);
2127 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2128 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2129 aStudyBuilder->RemoveObjectWithChildren( SO );
2131 else {// default action: remove SObject from the study
2132 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2133 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2135 aStudyBuilder->RemoveObjectWithChildren( SO );
2139 } /* listSO back loop */
2141 aStudyBuilder->CommitCommand();
2143 /* Clear any previous selection */
2145 aSel->setSelectedObjects( l1 );
2147 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2151 SMESHGUI_EXPORT CAM_Module* createModule()
2153 return new SMESHGUI();
2156 SMESHGUI_EXPORT char* getModuleVersion() {
2157 return (char*)SMESH_VERSION_STR;
2161 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2163 //=============================================================================
2167 //=============================================================================
2168 SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
2170 if ( CORBA::is_nil( myComponentSMESH ) )
2172 CORBA::Boolean anIsEmbeddedMode;
2173 SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
2174 if( dynamic_cast<SALOME_NamingService *>(ns) )
2175 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2178 Engines::EngineComponent_var comp = RetrieveSMESHInstance();
2179 myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
2182 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2184 // 0019923: EDF 765 SMESH : default values of hypothesis
2185 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2186 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2187 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2188 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2189 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2191 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2192 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2193 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2195 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2196 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2200 myActiveDialogBox = 0;
2201 myFilterLibraryDlg = 0;
2205 myEventCallbackCommand = vtkCallbackCommand::New();
2206 myEventCallbackCommand->Delete();
2207 myEventCallbackCommand->SetClientData( this );
2208 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2211 /* load resources for all available meshers */
2212 SMESH::InitAvailableHypotheses();
2215 //=============================================================================
2219 //=============================================================================
2220 SMESHGUI::~SMESHGUI()
2224 //=============================================================================
2228 //=============================================================================
2229 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2231 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2233 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2238 //=============================================================================
2242 //=============================================================================
2243 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2245 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2249 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2250 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2251 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2252 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2253 return autoUpdate && !exceeded;
2256 //=============================================================================
2260 //=============================================================================
2261 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2262 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2264 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2268 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2269 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2270 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2272 SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
2273 long nbOdElems = info[SMDSEntity_0D];
2274 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2275 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2276 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2277 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2278 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2279 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2280 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2281 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2282 info[SMDSEntity_Polyhedra] +
2283 info[SMDSEntity_Hexagonal_Prism];
2284 long nbBalls = info[SMDSEntity_Ball];
2286 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2287 *nbElements = requestedSize;
2289 *entities = SMESH_Actor::eAllEntity;
2292 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2294 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2296 if ( incrementalLimit ) {
2299 if ( nbOdElems > 0 ) {
2300 if ( total + nbOdElems > updateLimit ) {
2301 *entities = *entities & ~SMESH_Actor::e0DElements;
2302 *hidden = *hidden | SMESH_Actor::e0DElements;
2309 if ( nbEdges > 0 ) {
2310 if ( total + nbEdges > updateLimit ) {
2311 *entities = *entities & ~SMESH_Actor::eEdges;
2312 *hidden = *hidden | SMESH_Actor::eEdges;
2319 if ( nbFaces > 0 ) {
2320 if ( total + nbFaces > updateLimit ) {
2321 *entities = *entities & ~SMESH_Actor::eFaces;
2322 *hidden = *hidden | SMESH_Actor::eFaces;
2329 if ( nbVolumes > 0 ) {
2330 if ( total + nbVolumes > updateLimit ) {
2331 *entities = *entities & ~SMESH_Actor::eVolumes;
2332 *hidden = *hidden | SMESH_Actor::eVolumes;
2339 if ( nbBalls > 0 ) {
2340 if ( total + nbBalls > updateLimit ) {
2341 *entities = *entities & ~SMESH_Actor::eBallElem;
2342 *hidden = *hidden | SMESH_Actor::eBallElem;
2350 return autoUpdate && !exceeded;
2353 //=============================================================================
2357 //=============================================================================
2358 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2360 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2363 //=============================================================================
2367 //=============================================================================
2368 SMESHGUI* SMESHGUI::GetSMESHGUI()
2370 SMESHGUI* smeshMod = 0;
2371 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2374 CAM_Module* module = app->module( "Mesh" );
2375 smeshMod = dynamic_cast<SMESHGUI*>( module );
2383 Standard_EXPORT SMESHGUI* GetComponentGUI()
2385 return SMESHGUI::GetSMESHGUI();
2389 //=============================================================================
2393 //=============================================================================
2394 void SMESHGUI::SetState(int aState)
2399 //=============================================================================
2403 //=============================================================================
2404 void SMESHGUI::ResetState()
2409 //=============================================================================
2413 //=============================================================================
2414 void SMESHGUI::EmitSignalDeactivateDialog()
2416 emit SignalDeactivateActiveDialog();
2419 //=============================================================================
2423 //=============================================================================
2424 void SMESHGUI::EmitSignalStudyFrameChanged()
2426 emit SignalStudyFrameChanged();
2429 //=============================================================================
2433 //=============================================================================
2434 void SMESHGUI::EmitSignalCloseAllDialogs()
2436 emit SignalCloseAllDialogs();
2439 //=============================================================================
2443 //=============================================================================
2444 void SMESHGUI::EmitSignalVisibilityChanged()
2446 emit SignalVisibilityChanged();
2449 //=============================================================================
2453 //=============================================================================
2454 void SMESHGUI::EmitSignalCloseView()
2456 emit SignalCloseView();
2459 //=============================================================================
2463 //=============================================================================
2464 void SMESHGUI::EmitSignalActivatedViewManager()
2466 emit SignalActivatedViewManager();
2469 //=============================================================================
2473 //=============================================================================
2474 QDialog *SMESHGUI::GetActiveDialogBox()
2476 return myActiveDialogBox;
2479 //=============================================================================
2483 //=============================================================================
2484 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2486 myActiveDialogBox = (QDialog *) aDlg;
2490 //=============================================================================
2494 //=============================================================================
2495 SUIT_Desktop* SMESHGUI::desktop()
2497 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2499 return app->desktop();
2504 //=============================================================================
2508 //=============================================================================
2509 SalomeApp_Study* SMESHGUI::activeStudy()
2511 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2513 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2518 //=============================================================================
2522 //=============================================================================
2523 void SMESHGUI::Modified( bool theIsUpdateActions )
2525 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2526 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2527 appStudy->Modified();
2528 if( theIsUpdateActions )
2529 app->updateActions();
2534 //=============================================================================
2538 //=============================================================================
2539 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2541 /* Here the position is on the bottom right corner - 10 */
2542 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2544 SUIT_Desktop *PP = desktop();
2545 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2546 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2551 * \brief Verifies whether study of operation is locked
2552 * \param theMess - specifies whether message box must be shown if study is locked
2553 * \return State of study.
2555 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2556 * is locked when corresponding message box appears
2558 bool SMESHGUI::isStudyLocked( bool theMessage )
2560 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2563 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2564 QObject::tr( "WRN_WARNING" ),
2565 QObject::tr( "WRN_STUDY_LOCKED" ) );
2571 //=============================================================================
2575 //=============================================================================
2576 bool SMESHGUI::OnGUIEvent( int theCommandID )
2578 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2582 SUIT_ResourceMgr* mgr = resourceMgr();
2586 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2587 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2589 //QAction* act = action( theCommandID );
2591 switch (theCommandID) {
2592 case SMESHOp::OpDelete:
2593 if(isStudyLocked()) break;
2596 case SMESHOp::OpImportDAT:
2597 case SMESHOp::OpImportUNV:
2598 case SMESHOp::OpImportMED:
2599 case SMESHOp::OpImportSTL:
2600 case SMESHOp::OpImportCGNS:
2601 case SMESHOp::OpImportSAUV:
2602 case SMESHOp::OpImportGMF:
2603 case SMESHOp::OpPopupImportDAT:
2604 case SMESHOp::OpPopupImportUNV:
2605 case SMESHOp::OpPopupImportMED:
2606 case SMESHOp::OpPopupImportSTL:
2607 case SMESHOp::OpPopupImportCGNS:
2608 case SMESHOp::OpPopupImportSAUV:
2609 case SMESHOp::OpPopupImportGMF:
2611 if(isStudyLocked()) break;
2612 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2616 case SMESHOp::OpFileInformation:
2618 SALOME_ListIO selected;
2619 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2621 aSel->selectedObjects( selected );
2622 if( selected.Extent() )
2624 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2625 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2626 if ( !aMesh->_is_nil() )
2628 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2634 case SMESHOp::OpExportDAT:
2635 case SMESHOp::OpExportMED:
2636 case SMESHOp::OpExportUNV:
2637 case SMESHOp::OpExportSTL:
2638 case SMESHOp::OpExportCGNS:
2639 case SMESHOp::OpExportSAUV:
2640 case SMESHOp::OpExportGMF:
2641 case SMESHOp::OpPopupExportDAT:
2642 case SMESHOp::OpPopupExportMED:
2643 case SMESHOp::OpPopupExportUNV:
2644 case SMESHOp::OpPopupExportSTL:
2645 case SMESHOp::OpPopupExportCGNS:
2646 case SMESHOp::OpPopupExportSAUV:
2647 case SMESHOp::OpPopupExportGMF:
2649 ::ExportMeshToFile(theCommandID);
2653 case SMESHOp::OpReset: // SCALAR BAR
2655 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2656 SALOME_ListIO selected;
2658 aSel->selectedObjects( selected );
2660 SALOME_ListIteratorOfListIO it(selected);
2661 for( ; it.More(); it.Next()) {
2662 Handle(SALOME_InteractiveObject) anIO = it.Value();
2663 if( anIO->hasEntry() ) {
2664 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2665 anActor->SetControlMode( SMESH_Actor::eNone );
2666 #ifndef DISABLE_PLOT2DVIEWER
2667 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2669 anActor->UpdateFilter();
2673 SMESH::UpdateView();
2676 case SMESHOp::OpScalarBarProperties:
2678 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2681 case SMESHOp::OpShowScalarBar:
2683 // show/hide scalar bar
2684 ::ShowElement(theCommandID);
2687 case SMESHOp::OpSaveDistribution:
2689 // dump control distribution data to the text file
2690 ::SaveDistribution();
2694 case SMESHOp::OpShowDistribution:
2696 // show/hide distribution
2697 ::ShowElement(theCommandID);
2701 #ifndef DISABLE_PLOT2DVIEWER
2702 case SMESHOp::OpPlotDistribution:
2704 // plot distribution
2705 ::PlotDistribution();
2711 case SMESHOp::OpAutoColor:
2715 case SMESHOp::OpDisableAutoColor:
2716 ::DisableAutoColor();
2719 case SMESHOp::OpClipping:
2720 case SMESHOp::OpTransparency:
2721 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2724 case SMESHOp::OpDMWireframe:
2725 case SMESHOp::OpDMShading:
2726 case SMESHOp::OpDMNodes:
2727 case SMESHOp::OpDMShrink:
2728 ::SetDisplayMode(theCommandID, myMarkerMap);
2731 //2D quadratic representation
2732 case SMESHOp::OpRepresentationLines:
2733 case SMESHOp::OpRepresentationArcs:
2734 ::SetDisplayMode(theCommandID, myMarkerMap);
2738 case SMESHOp::OpDE0DElements:
2739 case SMESHOp::OpDEEdges:
2740 case SMESHOp::OpDEFaces:
2741 case SMESHOp::OpDEVolumes:
2742 case SMESHOp::OpDEBalls:
2743 case SMESHOp::OpDEAllEntity:
2744 ::SetDisplayEntity(theCommandID);
2747 // Choose entities to be displayed
2748 case SMESHOp::OpDEChoose:
2750 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2754 case SMESHOp::OpOrientationOnFaces:
2756 SUIT_OverrideCursor wc;
2757 LightApp_SelectionMgr* mgr = selectionMgr();
2758 SALOME_ListIO selected; mgr->selectedObjects( selected );
2760 SALOME_ListIteratorOfListIO it(selected);
2761 for( ; it.More(); it.Next()) {
2762 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2763 if(anIObject->hasEntry()) {
2764 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2765 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2772 case SMESHOp::OpUpdate:
2774 if(isStudyLocked()) break;
2775 SUIT_OverrideCursor wc;
2778 SMESH::UpdateView();
2780 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2781 SMESH::OnVisuException();
2783 catch (...) { // PAL16774 (Crash after display of many groups)
2784 SMESH::OnVisuException();
2788 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2789 aSel->selectedObjects( l );
2790 aSel->setSelectedObjects( l );
2794 case SMESHOp::OpHide:
2795 case SMESHOp::OpShow:
2796 case SMESHOp::OpShowOnly:
2798 SUIT_OverrideCursor wc;
2799 SMESH::EDisplaing anAction;
2800 switch (theCommandID) {
2801 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2802 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2803 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2806 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2807 SALOME_ListIO sel_objects, to_process;
2809 aSel->selectedObjects( sel_objects );
2811 if ( theCommandID==SMESHOp::OpShowOnly )
2813 //MESSAGE("anAction = SMESH::eDisplayOnly");
2814 startOperation( myEraseAll );
2817 extractContainers( sel_objects, to_process );
2822 SALOME_ListIteratorOfListIO It( to_process );
2823 for ( ; It.More(); It.Next())
2825 Handle(SALOME_InteractiveObject) IOS = It.Value();
2826 if ( IOS->hasEntry() )
2828 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2829 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2830 break; // PAL16774 (Crash after display of many groups)
2832 if (anAction == SMESH::eDisplayOnly)
2833 anAction = SMESH::eDisplay;
2838 // PAL13338 + PAL15161 -->
2839 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2840 SMESH::UpdateView();
2841 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2843 // PAL13338 + PAL15161 <--
2845 catch (...) { // PAL16774 (Crash after display of many groups)
2846 SMESH::OnVisuException();
2849 if (anAction == SMESH::eErase) {
2851 aSel->setSelectedObjects( l1 );
2854 aSel->setSelectedObjects( to_process );
2856 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2857 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2858 vtkwnd->GetRenderer()->AdjustActors();
2863 case SMESHOp::OpNode:
2865 if(isStudyLocked()) break;
2868 EmitSignalDeactivateDialog();
2870 ( new SMESHGUI_NodesDlg( this ) )->show();
2873 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2878 case SMESHOp::OpEditMeshOrSubMesh:
2879 case SMESHOp::OpEditMesh:
2880 case SMESHOp::OpEditSubMesh:
2881 case SMESHOp::OpMeshOrder:
2882 case SMESHOp::OpCreateSubMesh:
2883 if ( warnOnGeomModif() )
2884 break; // action forbidden as geometry modified
2886 case SMESHOp::OpCreateMesh:
2887 case SMESHOp::OpCompute:
2888 case SMESHOp::OpComputeSubMesh:
2889 case SMESHOp::OpPreCompute:
2890 case SMESHOp::OpEvaluate:
2891 case SMESHOp::OpShowErrors:
2892 startOperation( theCommandID );
2894 case SMESHOp::OpRecompute:
2896 if ( isStudyLocked() )
2898 SALOME_ListIO selected;
2899 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2900 sel->selectedObjects( selected );
2901 if ( selected.Extent() == 1 ) {
2902 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2903 if ( !aMesh->_is_nil() )
2905 startOperation( SMESHOp::OpCompute );
2909 case SMESHOp::OpCopyMesh:
2911 if (isStudyLocked()) break;
2912 EmitSignalDeactivateDialog();
2913 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2916 case SMESHOp::OpBuildCompoundMesh:
2918 if (isStudyLocked()) break;
2919 EmitSignalDeactivateDialog();
2920 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2924 case SMESHOp::OpDiagonalInversion:
2925 case SMESHOp::OpUnionOfTwoTriangle:
2929 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2933 if ( isStudyLocked() )
2935 if ( warnOnGeomModif() )
2936 break; // action forbidden as geometry modified
2938 /*Standard_Boolean aRes;
2939 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2940 if ( aMesh->_is_nil() )
2942 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2943 tr( "SMESH_BAD_SELECTION" ) );
2947 EmitSignalDeactivateDialog();
2948 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2949 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2951 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2954 case SMESHOp::OpOrientation:
2955 case SMESHOp::OpUnionOfTriangles:
2956 case SMESHOp::OpCuttingOfQuadrangles:
2957 case SMESHOp::OpSplitVolumes:
2961 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2965 if ( isStudyLocked() )
2967 if ( warnOnGeomModif() )
2968 break; // action forbidden as geometry modified
2970 EmitSignalDeactivateDialog();
2971 SMESHGUI_MultiEditDlg* aDlg = NULL;
2972 if ( theCommandID == SMESHOp::OpOrientation )
2973 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2974 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2975 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2976 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2977 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2979 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2984 case SMESHOp::OpSmoothing:
2986 if(isStudyLocked()) break;
2987 if ( warnOnGeomModif() )
2988 break; // action forbidden as geometry modified
2990 EmitSignalDeactivateDialog();
2991 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2994 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2998 case SMESHOp::OpExtrusion:
3000 if (isStudyLocked()) break;
3001 if ( warnOnGeomModif() )
3002 break; // action forbidden as geometry modified
3004 EmitSignalDeactivateDialog();
3005 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
3007 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3011 case SMESHOp::OpExtrusionAlongAPath:
3013 if (isStudyLocked()) break;
3014 if ( warnOnGeomModif() )
3015 break; // action forbidden as geometry modified
3017 EmitSignalDeactivateDialog();
3018 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3020 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3024 case SMESHOp::OpRevolution:
3026 if(isStudyLocked()) break;
3027 if ( warnOnGeomModif() )
3028 break; // action forbidden as geometry modified
3030 EmitSignalDeactivateDialog();
3031 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3034 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3038 case SMESHOp::OpPatternMapping:
3040 if ( isStudyLocked() )
3042 if ( warnOnGeomModif() )
3043 break; // action forbidden as geometry modified
3046 EmitSignalDeactivateDialog();
3047 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3050 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3054 // Adaptation - begin
3055 #ifndef DISABLE_MG_ADAPT
3056 case SMESHOp::OpMGAdapt:
3058 if ( isStudyLocked() )
3060 EmitSignalDeactivateDialog();
3062 SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
3063 bool isCreation = false;
3064 ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
3069 case SMESHOp::OpSplitBiQuadratic:
3070 case SMESHOp::OpConvertMeshToQuadratic:
3071 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3072 case SMESHOp::OpReorientFaces:
3073 case SMESHOp::OpCreateGeometryGroup:
3075 if ( warnOnGeomModif() )
3076 break; // action forbidden as geometry modified
3077 startOperation( theCommandID );
3080 case SMESHOp::OpCreateGroup:
3084 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3088 if(isStudyLocked()) break;
3089 if ( warnOnGeomModif() )
3090 break; // action forbidden as geometry modified
3091 EmitSignalDeactivateDialog();
3092 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3094 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3095 SALOME_ListIO selected;
3097 aSel->selectedObjects( selected );
3099 int nbSel = selected.Extent();
3101 // check if mesh is selected
3102 aMesh = SMESH::GetMeshByIO( selected.First() );
3104 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3109 case SMESHOp::OpConstructGroup:
3113 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3117 if(isStudyLocked()) break;
3118 if ( warnOnGeomModif() )
3119 break; // action forbidden as geometry modified
3120 EmitSignalDeactivateDialog();
3122 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3123 SALOME_ListIO selected;
3125 aSel->selectedObjects( selected );
3127 int nbSel = selected.Extent();
3129 // check if submesh is selected
3130 Handle(SALOME_InteractiveObject) IObject = selected.First();
3131 if (IObject->hasEntry()) {
3132 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3134 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3135 if (!aSubMesh->_is_nil()) {
3137 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3138 // get submesh elements list by types
3139 SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3140 SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3141 SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3142 SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3143 // create group for each type o elements
3144 QString aName = IObject->getName();
3145 QStringList anEntryList;
3146 if (aNodes->length() > 0) {
3147 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3148 aGroup->Add(aNodes.inout());
3149 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3150 anEntryList.append( aSObject->GetID().c_str() );
3152 if (aEdges->length() > 0) {
3153 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3154 aGroup->Add(aEdges.inout());
3155 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3156 anEntryList.append( aSObject->GetID().c_str() );
3158 if (aFaces->length() > 0) {
3159 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3160 aGroup->Add(aFaces.inout());
3161 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3162 anEntryList.append( aSObject->GetID().c_str() );
3164 if (aVolumes->length() > 0) {
3165 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3166 aGroup->Add(aVolumes.inout());
3167 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3168 anEntryList.append( aSObject->GetID().c_str() );
3171 anApp->browseObjects( anEntryList );
3173 catch(const SALOME::SALOME_Exception & S_ex){
3174 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3181 SUIT_MessageBox::warning(desktop(),
3182 tr("SMESH_WRN_WARNING"),
3183 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3188 case SMESHOp::OpEditGroup:
3192 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3196 if(isStudyLocked()) break;
3197 if ( warnOnGeomModif() )
3198 break; // action forbidden as geometry modified
3199 EmitSignalDeactivateDialog();
3201 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3202 SALOME_ListIO selected;
3204 aSel->selectedObjects( selected );
3206 SALOME_ListIteratorOfListIO It (selected);
3207 int nbSelectedGroups = 0;
3208 for ( ; It.More(); It.Next() )
3210 SMESH::SMESH_GroupBase_var aGroup =
3211 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3212 if (!aGroup->_is_nil()) {
3214 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3218 if (nbSelectedGroups == 0)
3220 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3226 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3228 if(isStudyLocked()) break;
3229 if (myState == 800) {
3230 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3231 if (aDlg) aDlg->onAdd();
3236 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3238 if(isStudyLocked()) break;
3239 if (myState == 800) {
3240 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3241 if (aDlg) aDlg->onRemove();
3246 case SMESHOp::OpEditGeomGroupAsGroup:
3250 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3254 if(isStudyLocked()) break;
3255 EmitSignalDeactivateDialog();
3257 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3258 SALOME_ListIO selected;
3260 aSel->selectedObjects( selected );
3262 SALOME_ListIteratorOfListIO It (selected);
3263 for ( ; It.More(); It.Next() )
3265 SMESH::SMESH_GroupOnGeom_var aGroup =
3266 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3267 if (!aGroup->_is_nil()) {
3268 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3273 SMESH::SMESH_GroupOnFilter_var aGroup =
3274 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3275 if (!aGroup->_is_nil()) {
3276 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3284 case SMESHOp::OpUnionGroups:
3285 case SMESHOp::OpIntersectGroups:
3286 case SMESHOp::OpCutGroups:
3290 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3294 if ( isStudyLocked() )
3296 if ( warnOnGeomModif() )
3297 break; // action forbidden as geometry modified
3299 EmitSignalDeactivateDialog();
3301 SMESHGUI_GroupOpDlg* aDlg = 0;
3302 if ( theCommandID == SMESHOp::OpUnionGroups )
3303 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3304 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3305 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3307 aDlg = new SMESHGUI_CutGroupsDlg( this );
3314 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3316 if ( isStudyLocked() )
3318 if ( warnOnGeomModif() )
3319 break; // action forbidden as geometry modified
3321 EmitSignalDeactivateDialog();
3322 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3328 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3330 if ( isStudyLocked() )
3332 if ( warnOnGeomModif() )
3333 break; // action forbidden as geometry modified
3335 EmitSignalDeactivateDialog();
3336 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3342 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3346 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3350 if ( isStudyLocked() )
3353 EmitSignalDeactivateDialog();
3355 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3359 case SMESHOp::OpMeshInformation:
3360 case SMESHOp::OpWhatIs:
3362 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3363 EmitSignalDeactivateDialog();
3364 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3365 SALOME_ListIO selected;
3367 aSel->selectedObjects( selected );
3369 if ( selected.Extent() > 1 ) { // a dlg for each IO
3370 SALOME_ListIteratorOfListIO It( selected );
3371 for ( ; It.More(); It.Next() ) {
3372 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3373 dlg->showInfo( It.Value() );
3378 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3384 case SMESHOp::OpFindElementByPoint:
3386 startOperation( theCommandID );
3390 case SMESHOp::OpEditHypothesis:
3392 if(isStudyLocked()) break;
3393 if ( warnOnGeomModif() )
3394 break; // action forbidden as geometry modified
3396 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3397 SALOME_ListIO selected;
3399 aSel->selectedObjects( selected );
3401 int nbSel = selected.Extent();
3404 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3405 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3407 if ( !aHypothesis->_is_nil() )
3409 SMESHGUI_GenericHypothesisCreator* aCreator =
3410 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3413 // set geometry of mesh and sub-mesh to aCreator
3414 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3415 if ( selected.Extent() == 1 )
3417 QString subGeomID, meshGeomID;
3418 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3419 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3421 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3422 aCreator->setShapeEntry( subGeomID );
3423 aCreator->setMainShapeEntry( meshGeomID );
3427 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3437 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3439 if(isStudyLocked()) break;
3440 if ( warnOnGeomModif() )
3441 break; // action forbidden as geometry modified
3442 SUIT_OverrideCursor wc;
3444 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3445 SALOME_ListIO selected;
3447 aSel->selectedObjects( selected, QString::null, false );
3449 SALOME_ListIteratorOfListIO It(selected);
3450 for (int i = 0; It.More(); It.Next(), i++) {
3451 Handle(SALOME_InteractiveObject) IObject = It.Value();
3452 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3455 aSel->setSelectedObjects( l1 );
3460 case SMESHOp::OpElem0D:
3461 case SMESHOp::OpBall:
3462 case SMESHOp::OpEdge:
3463 case SMESHOp::OpTriangle:
3464 case SMESHOp::OpQuadrangle:
3465 case SMESHOp::OpPolygon:
3466 case SMESHOp::OpTetrahedron:
3467 case SMESHOp::OpHexahedron:
3468 case SMESHOp::OpPentahedron:
3469 case SMESHOp::OpPyramid:
3470 case SMESHOp::OpHexagonalPrism:
3472 if(isStudyLocked()) break;
3473 if ( warnOnGeomModif() )
3474 break; // action forbidden as geometry modified
3476 EmitSignalDeactivateDialog();
3477 SMDSAbs_EntityType type = SMDSEntity_Edge;
3478 switch (theCommandID) {
3479 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3480 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3481 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3482 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3483 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3484 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3485 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3486 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3487 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3488 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3491 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3494 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3498 case SMESHOp::OpPolyhedron:
3500 if(isStudyLocked()) break;
3501 if ( warnOnGeomModif() )
3502 break; // action forbidden as geometry modified
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3508 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3512 case SMESHOp::OpQuadraticEdge:
3513 case SMESHOp::OpQuadraticTriangle:
3514 case SMESHOp::OpBiQuadraticTriangle:
3515 case SMESHOp::OpQuadraticQuadrangle:
3516 case SMESHOp::OpBiQuadraticQuadrangle:
3517 case SMESHOp::OpQuadraticPolygon:
3518 case SMESHOp::OpQuadraticTetrahedron:
3519 case SMESHOp::OpQuadraticPyramid:
3520 case SMESHOp::OpQuadraticPentahedron:
3521 case SMESHOp::OpBiQuadraticPentahedron:
3522 case SMESHOp::OpQuadraticHexahedron:
3523 case SMESHOp::OpTriQuadraticHexahedron:
3525 if(isStudyLocked()) break;
3526 if ( warnOnGeomModif() )
3527 break; // action forbidden as geometry modified
3529 EmitSignalDeactivateDialog();
3530 SMDSAbs_EntityType type = SMDSEntity_Last;
3532 switch (theCommandID) {
3533 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3534 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3535 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3536 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3537 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3538 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3539 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3540 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3541 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3542 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3543 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3544 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3547 if ( type != SMDSEntity_Last )
3548 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3551 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3552 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3556 case SMESHOp::OpRemoveNodes:
3558 if(isStudyLocked()) break;
3559 if ( warnOnGeomModif() )
3560 break; // action forbidden as geometry modified
3562 EmitSignalDeactivateDialog();
3563 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3566 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3567 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3571 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3573 if(isStudyLocked()) break;
3574 if ( warnOnGeomModif() )
3575 break; // action forbidden as geometry modified
3577 EmitSignalDeactivateDialog();
3578 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3582 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3583 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3587 case SMESHOp::OpClearMesh: {
3589 if(isStudyLocked()) break;
3590 if ( warnOnGeomModif() )
3591 break; // action forbidden as geometry modified
3593 SALOME_ListIO selected;
3594 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3595 aSel->selectedObjects( selected );
3597 SUIT_OverrideCursor wc;
3598 SALOME_ListIteratorOfListIO It (selected);
3599 for ( ; It.More(); It.Next() )
3601 Handle(SALOME_InteractiveObject) IOS = It.Value();
3602 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3603 if ( aMesh->_is_nil()) continue;
3606 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3607 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3608 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3609 // hide groups and submeshes
3610 _PTR(ChildIterator) anIter =
3611 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3612 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3614 _PTR(SObject) so = anIter->Value();
3615 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3618 catch (const SALOME::SALOME_Exception& S_ex){
3620 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3624 SMESH::UpdateView();
3628 case SMESHOp::OpRemoveOrphanNodes:
3630 if(isStudyLocked()) break;
3631 if ( warnOnGeomModif() )
3632 break; // action forbidden as geometry modified
3633 SALOME_ListIO selected;
3634 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3635 aSel->selectedObjects( selected );
3636 if ( selected.Extent() == 1 ) {
3637 Handle(SALOME_InteractiveObject) anIO = selected.First();
3638 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3639 if ( !aMesh->_is_nil() ) {
3640 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3641 tr( "SMESH_WARNING" ),
3642 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3643 SUIT_MessageBox::Yes |
3644 SUIT_MessageBox::No,
3645 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3648 SUIT_OverrideCursor wc;
3649 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3650 smIdType removed = aMeshEditor->RemoveOrphanNodes();
3651 SUIT_MessageBox::information(SMESHGUI::desktop(),
3652 tr("SMESH_INFORMATION"),
3653 tr("NB_NODES_REMOVED").arg(removed));
3654 if ( removed > 0 ) {
3655 SMESH::UpdateView();
3656 SMESHGUI::Modified();
3659 catch (const SALOME::SALOME_Exception& S_ex) {
3660 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3669 case SMESHOp::OpRenumberingNodes:
3671 if(isStudyLocked()) break;
3672 if ( warnOnGeomModif() )
3673 break; // action forbidden as geometry modified
3675 EmitSignalDeactivateDialog();
3676 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3680 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3681 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3685 case SMESHOp::OpRenumberingElements:
3687 if(isStudyLocked()) break;
3688 if ( warnOnGeomModif() )
3689 break; // action forbidden as geometry modified
3691 EmitSignalDeactivateDialog();
3692 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3696 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3697 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3701 case SMESHOp::OpTranslation:
3703 if(isStudyLocked()) break;
3704 if ( warnOnGeomModif() )
3705 break; // action forbidden as geometry modified
3707 EmitSignalDeactivateDialog();
3708 ( new SMESHGUI_TranslationDlg( this ) )->show();
3711 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3712 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3716 case SMESHOp::OpRotation:
3718 if(isStudyLocked()) break;
3719 if ( warnOnGeomModif() )
3720 break; // action forbidden as geometry modified
3722 EmitSignalDeactivateDialog();
3723 ( new SMESHGUI_RotationDlg( this ) )->show();
3726 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3727 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3731 case SMESHOp::OpSymmetry:
3733 if(isStudyLocked()) break;
3734 if ( warnOnGeomModif() )
3735 break; // action forbidden as geometry modified
3737 EmitSignalDeactivateDialog();
3738 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3741 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3742 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3746 case SMESHOp::OpScale:
3748 if(isStudyLocked()) break;
3749 if ( warnOnGeomModif() )
3750 break; // action forbidden as geometry modified
3752 EmitSignalDeactivateDialog();
3753 ( new SMESHGUI_ScaleDlg( this ) )->show();
3756 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3757 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3762 case SMESHOp::OpOffset:
3764 if(isStudyLocked()) break;
3765 if ( warnOnGeomModif() )
3766 break; // action forbidden as geometry modified
3768 EmitSignalDeactivateDialog();
3769 ( new SMESHGUI_OffsetDlg( this ) )->show();
3772 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3773 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3778 case SMESHOp::OpSewing:
3780 if(isStudyLocked()) break;
3781 if ( warnOnGeomModif() )
3782 break; // action forbidden as geometry modified
3784 EmitSignalDeactivateDialog();
3785 ( new SMESHGUI_SewingDlg( this ) )->show();
3788 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3789 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3793 case SMESHOp::OpMergeNodes:
3795 if(isStudyLocked()) break;
3796 if ( warnOnGeomModif() )
3797 break; // action forbidden as geometry modified
3799 EmitSignalDeactivateDialog();
3800 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3803 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3804 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3808 case SMESHOp::OpMergeElements:
3810 if (isStudyLocked()) break;
3811 if ( warnOnGeomModif() )
3812 break; // action forbidden as geometry modified
3814 EmitSignalDeactivateDialog();
3815 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3817 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3818 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3823 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3824 if ( warnOnGeomModif() )
3825 break; // action forbidden as geometry modified
3826 startOperation( SMESHOp::OpMoveNode );
3829 case SMESHOp::OpDuplicateNodes:
3831 if(isStudyLocked()) break;
3832 if ( warnOnGeomModif() )
3833 break; // action forbidden as geometry modified
3835 EmitSignalDeactivateDialog();
3836 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3839 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3840 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3845 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3846 if ( warnOnGeomModif() )
3847 break; // action forbidden as geometry modified
3848 startOperation( SMESHOp::OpElem0DOnElemNodes );
3851 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3853 static QList<int> aTypes;
3854 if ( aTypes.isEmpty() )
3856 aTypes.append( SMESH::NODE );
3857 aTypes.append( SMESH::EDGE );
3858 aTypes.append( SMESH::FACE );
3859 aTypes.append( SMESH::VOLUME );
3861 if (!myFilterLibraryDlg)
3862 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3863 else if (myFilterLibraryDlg->isHidden())
3864 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3865 myFilterLibraryDlg->raise();
3869 case SMESHOp::OpFreeNode:
3870 case SMESHOp::OpEqualNode:
3871 case SMESHOp::OpNodeConnectivityNb:
3872 case SMESHOp::OpFreeEdge:
3873 case SMESHOp::OpFreeBorder:
3874 case SMESHOp::OpLength:
3875 case SMESHOp::OpConnection:
3876 case SMESHOp::OpEqualEdge:
3877 case SMESHOp::OpFreeFace:
3878 case SMESHOp::OpBareBorderFace:
3879 case SMESHOp::OpOverConstrainedFace:
3880 case SMESHOp::OpLength2D:
3881 case SMESHOp::OpDeflection2D:
3882 case SMESHOp::OpConnection2D:
3883 case SMESHOp::OpArea:
3884 case SMESHOp::OpTaper:
3885 case SMESHOp::OpAspectRatio:
3886 case SMESHOp::OpMinimumAngle:
3887 case SMESHOp::OpWarpingAngle:
3888 case SMESHOp::OpSkew:
3889 case SMESHOp::OpMaxElementLength2D:
3890 case SMESHOp::OpEqualFace:
3891 case SMESHOp::OpAspectRatio3D:
3892 case SMESHOp::OpVolume:
3893 case SMESHOp::OpMaxElementLength3D:
3894 case SMESHOp::OpBareBorderVolume:
3895 case SMESHOp::OpOverConstrainedVolume:
3896 case SMESHOp::OpEqualVolume:
3899 LightApp_SelectionMgr* mgr = selectionMgr();
3900 SALOME_ListIO selected; mgr->selectedObjects( selected );
3902 if( !selected.IsEmpty() ) {
3903 SUIT_OverrideCursor wc;
3904 ::Control( theCommandID );
3907 SUIT_MessageBox::warning(desktop(),
3908 tr( "SMESH_WRN_WARNING" ),
3909 tr( "SMESH_BAD_SELECTION" ) );
3913 SUIT_MessageBox::warning(desktop(),
3914 tr( "SMESH_WRN_WARNING" ),
3915 tr( "NOT_A_VTK_VIEWER" ) );
3918 case SMESHOp::OpOverallMeshQuality:
3919 OverallMeshQuality();
3921 case SMESHOp::OpNumberingNodes:
3923 SUIT_OverrideCursor wc;
3924 LightApp_SelectionMgr* mgr = selectionMgr();
3925 SALOME_ListIO selected; mgr->selectedObjects( selected );
3927 SALOME_ListIteratorOfListIO it(selected);
3928 for( ; it.More(); it.Next()) {
3929 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3930 if(anIObject->hasEntry()) {
3931 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3932 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3938 case SMESHOp::OpNumberingElements:
3940 SUIT_OverrideCursor wc;
3941 LightApp_SelectionMgr* mgr = selectionMgr();
3942 SALOME_ListIO selected; mgr->selectedObjects( selected );
3944 SALOME_ListIteratorOfListIO it(selected);
3945 for( ; it.More(); it.Next()) {
3946 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3947 if(anIObject->hasEntry())
3948 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3949 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3954 case SMESHOp::OpPropertiesLength:
3955 case SMESHOp::OpPropertiesArea:
3956 case SMESHOp::OpPropertiesVolume:
3957 case SMESHOp::OpMinimumDistance:
3958 case SMESHOp::OpBoundingBox:
3959 case SMESHOp::OpAngle:
3961 int page = SMESHGUI_MeasureDlg::MinDistance;
3962 if ( theCommandID == SMESHOp::OpBoundingBox )
3963 page = SMESHGUI_MeasureDlg::BoundingBox;
3964 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3965 page = SMESHGUI_MeasureDlg::Length;
3966 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3967 page = SMESHGUI_MeasureDlg::Area;
3968 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3969 page = SMESHGUI_MeasureDlg::Volume;
3970 else if ( theCommandID == SMESHOp::OpAngle )
3971 page = SMESHGUI_MeasureDlg::Angle;
3973 EmitSignalDeactivateDialog();
3974 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3978 case SMESHOp::OpSortChild:
3981 case SMESHOp::OpBreakLink:
3982 ::breakShaperLink();
3987 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3988 //updateObjBrowser();
3992 //=============================================================================
3996 //=============================================================================
3997 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4002 //=============================================================================
4006 //=============================================================================
4007 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4012 //=============================================================================
4016 //=============================================================================
4017 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4022 //=============================================================================
4023 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4024 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4026 //=============================================================================
4027 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4028 SUIT_ViewWindow* wnd )
4030 if(theIO->hasEntry()){
4031 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4032 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4036 //=======================================================================
4037 // function : createSMESHAction
4039 //=======================================================================
4040 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4041 const int key, const bool toggle, const QString& shortcutAction )
4044 QWidget* parent = application()->desktop();
4045 SUIT_ResourceMgr* resMgr = resourceMgr();
4047 if ( !icon_id.isEmpty() )
4048 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4050 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4051 if ( !pix.isNull() )
4052 icon = QIcon( pix );
4054 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4055 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4056 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4058 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4059 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4062 //=======================================================================
4063 // function : createPopupItem
4065 //=======================================================================
4066 void SMESHGUI::createPopupItem( const int id,
4067 const QString& clients,
4068 const QString& types,
4069 const QString& theRule,
4072 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4073 popupMgr()->insert( action( id ), pId, 0 );
4075 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4076 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4077 QString rule = "(%1) and (%2) and (%3)";
4078 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4079 if( clients.isEmpty() )
4080 rule = rule.arg( QString( "true" ) );
4082 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4083 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4086 bool cont = myRules.contains( id );
4088 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4090 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4091 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4094 //=======================================================================
4095 // function : initialize
4097 //=======================================================================
4098 void SMESHGUI::initialize( CAM_Application* app )
4100 SalomeApp_Module::initialize( app );
4102 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4104 /* Automatic Update flag */
4105 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4107 // ----- create actions --------------
4109 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4110 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4111 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4112 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4114 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4116 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4117 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4118 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4119 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4120 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4122 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4124 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4125 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4127 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4128 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4129 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4130 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4132 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4134 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4135 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4136 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4137 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4138 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4139 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4141 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4143 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4144 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4145 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4146 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4147 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4148 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4149 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4150 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4151 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4152 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4153 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4154 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4155 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4156 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4157 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4158 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4159 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4160 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4161 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4162 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4163 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4164 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4165 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4166 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4167 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4168 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4169 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4170 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4171 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4172 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4173 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4174 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4175 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4176 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4177 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4178 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4180 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4181 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4182 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4183 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4184 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4185 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4186 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4187 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4188 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4189 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4190 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4191 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4192 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4193 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4194 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4195 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4196 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4197 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4198 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4199 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4200 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4201 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4202 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4203 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4204 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4205 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4206 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4207 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4208 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4210 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4211 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4212 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4213 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4214 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4215 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4216 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4217 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4218 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4219 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4220 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4221 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4222 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4223 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4224 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4225 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4226 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4227 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4228 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4229 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4230 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4231 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4232 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4233 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4234 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4235 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4237 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4238 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4239 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4240 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4242 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4243 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4245 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4246 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4247 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4248 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4249 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4250 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4251 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4252 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4253 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4254 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4255 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4256 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4257 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4258 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4259 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4260 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4261 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4262 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4263 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4264 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4265 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4266 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4267 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4268 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4269 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4271 createSMESHAction( SMESHOp::OpReset, "RESET" );
4272 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4273 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4274 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4275 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4276 #ifndef DISABLE_PLOT2DVIEWER
4277 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4279 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4280 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4281 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4282 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4283 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4284 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4285 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4286 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4287 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4288 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4289 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4290 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4291 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4293 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4294 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4296 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4297 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4298 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4299 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4300 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4301 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4302 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4303 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4304 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4306 // Adaptation - begin
4307 #ifndef DISABLE_MG_ADAPT
4308 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4312 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4313 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4314 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4315 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4316 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4317 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4319 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4320 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4321 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4323 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4325 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4327 QList<int> aCtrlActions;
4328 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4329 << SMESHOp::OpNodeConnectivityNb // node controls
4330 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4331 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4332 << SMESHOp::OpDeflection2D
4333 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4334 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4335 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4336 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4337 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4338 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4339 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4340 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4341 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4342 aCtrlGroup->setExclusive( true );
4343 for( int i = 0; i < aCtrlActions.size(); i++ )
4344 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4346 // ----- create menu --------------
4347 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4348 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4349 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4350 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4351 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4352 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4353 #ifndef DISABLE_MG_ADAPT
4354 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4356 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4357 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4359 createMenu( separator(), fileId );
4361 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4362 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4363 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4364 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4365 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4366 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4367 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4368 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4369 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4370 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4371 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4372 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4373 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4375 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4376 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4377 createMenu( SMESHOp::OpImportMED, importId, -1 );
4378 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4380 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4382 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4383 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4384 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4385 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4386 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4387 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4389 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4391 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4392 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4393 createMenu( separator(), fileId, 10 );
4395 createMenu( SMESHOp::OpDelete, editId, -1 );
4397 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4399 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4400 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4401 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4402 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4403 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4404 createMenu( separator(), meshId, -1 );
4405 createMenu( SMESHOp::OpCompute, meshId, -1 );
4406 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4407 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4408 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4409 createMenu( separator(), meshId, -1 );
4410 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4411 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4412 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4413 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4414 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4415 createMenu( separator(), meshId, -1 );
4416 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4417 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4418 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4419 createMenu( separator(), meshId, -1 );
4420 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4421 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4422 createMenu( separator(), meshId, -1 );
4423 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4424 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4425 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4426 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4427 createMenu( separator(), meshId, -1 );
4429 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4430 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4431 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4432 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4433 createMenu( SMESHOp::OpLength, edgeId, -1 );
4434 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4435 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4436 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4437 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4438 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4439 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4440 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4441 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4442 createMenu( SMESHOp::OpArea, faceId, -1 );
4443 createMenu( SMESHOp::OpTaper, faceId, -1 );
4444 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4445 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4446 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4447 createMenu( SMESHOp::OpSkew, faceId, -1 );
4448 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4449 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4450 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4451 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4452 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4453 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4454 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4455 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4456 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4457 createMenu( separator(), ctrlId, -1 );
4458 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4459 createMenu( separator(), ctrlId, -1 );
4460 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4462 createMenu( SMESHOp::OpNode, addId, -1 );
4463 createMenu( SMESHOp::OpElem0D, addId, -1 );
4464 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4465 createMenu( SMESHOp::OpBall, addId, -1 );
4466 createMenu( SMESHOp::OpEdge, addId, -1 );
4467 createMenu( SMESHOp::OpTriangle, addId, -1 );
4468 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4469 createMenu( SMESHOp::OpPolygon, addId, -1 );
4470 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4471 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4472 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4473 createMenu( SMESHOp::OpPyramid, addId, -1 );
4474 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4475 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4476 createMenu( separator(), addId, -1 );
4477 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4478 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4479 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4480 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4481 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4482 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4483 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4484 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4485 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4486 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4487 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4488 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4490 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4491 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4492 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4493 createMenu( separator(), removeId, -1 );
4494 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4495 createMenu( separator(), removeId, -1 );
4496 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4498 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4499 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4501 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4502 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4503 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4504 createMenu( SMESHOp::OpRotation, transfId, -1 );
4505 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4506 createMenu( SMESHOp::OpScale, transfId, -1 );
4507 createMenu( SMESHOp::OpOffset, transfId, -1 );
4508 createMenu( SMESHOp::OpSewing, transfId, -1 );
4509 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4511 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4512 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4513 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4514 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4515 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4516 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4517 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4518 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4519 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4520 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4521 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4522 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4523 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4524 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4525 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4526 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4528 // Adaptation - begin
4529 #ifndef DISABLE_MG_ADAPT
4530 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4534 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4535 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4536 createMenu( SMESHOp::OpAngle, measureId, -1 );
4537 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4538 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4539 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4540 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4542 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4543 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4544 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4545 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4547 // ----- create toolbars --------------
4548 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4549 createTool( SMESHOp::OpCreateMesh, meshTb );
4550 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4551 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4552 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4553 createTool( SMESHOp::OpCopyMesh, meshTb );
4554 createTool( separator(), meshTb );
4555 createTool( SMESHOp::OpCompute, meshTb );
4556 createTool( SMESHOp::OpPreCompute, meshTb );
4557 createTool( SMESHOp::OpEvaluate, meshTb );
4558 createTool( SMESHOp::OpMeshOrder, meshTb );
4560 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4561 createTool( SMESHOp::OpMeshInformation, infoTb );
4562 //createTool( SMESHOp::OpStdInfo, meshTb );
4563 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4564 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4566 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4567 createTool( SMESHOp::OpCreateGroup, groupTb );
4568 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4569 createTool( SMESHOp::OpConstructGroup, groupTb );
4570 createTool( SMESHOp::OpEditGroup, groupTb );
4572 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4573 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4574 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4575 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4577 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4578 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4579 createTool( SMESHOp::OpLength, ctrl1dTb );
4580 createTool( SMESHOp::OpConnection, ctrl1dTb );
4581 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4583 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4584 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4585 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4586 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4587 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4588 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4589 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4590 createTool( SMESHOp::OpArea, ctrl2dTb );
4591 createTool( SMESHOp::OpTaper, ctrl2dTb );
4592 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4593 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4594 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4595 createTool( SMESHOp::OpSkew, ctrl2dTb );
4596 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4597 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4598 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4600 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4601 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4602 createTool( SMESHOp::OpVolume, ctrl3dTb );
4603 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4604 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4605 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4606 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4608 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4609 createTool( SMESHOp::OpNode, addElemTb );
4610 createTool( SMESHOp::OpElem0D, addElemTb );
4611 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4612 createTool( SMESHOp::OpBall, addElemTb );
4613 createTool( SMESHOp::OpEdge, addElemTb );
4614 createTool( SMESHOp::OpTriangle, addElemTb );
4615 createTool( SMESHOp::OpQuadrangle, addElemTb );
4616 createTool( SMESHOp::OpPolygon, addElemTb );
4617 createTool( SMESHOp::OpTetrahedron, addElemTb );
4618 createTool( SMESHOp::OpHexahedron, addElemTb );
4619 createTool( SMESHOp::OpPentahedron, addElemTb );
4620 createTool( SMESHOp::OpPyramid, addElemTb );
4621 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4622 createTool( SMESHOp::OpPolyhedron, addElemTb );
4624 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4625 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4626 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4627 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4628 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4629 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4630 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4631 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4632 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4633 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4634 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4635 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4636 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4638 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4639 createTool( SMESHOp::OpRemoveNodes, remTb );
4640 createTool( SMESHOp::OpRemoveElements, remTb );
4641 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4642 createTool( SMESHOp::OpClearMesh, remTb );
4644 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4645 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4646 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4648 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4649 createTool( SMESHOp::OpMergeNodes, transformTb );
4650 createTool( SMESHOp::OpMergeElements, transformTb );
4651 createTool( SMESHOp::OpTranslation, transformTb );
4652 createTool( SMESHOp::OpRotation, transformTb );
4653 createTool( SMESHOp::OpSymmetry, transformTb );
4654 createTool( SMESHOp::OpScale, transformTb );
4655 createTool( SMESHOp::OpOffset, transformTb );
4656 createTool( SMESHOp::OpSewing, transformTb );
4657 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4659 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4660 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4661 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4662 createTool( SMESHOp::OpExtrusion, modifyTb );
4663 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4664 createTool( SMESHOp::OpRevolution, modifyTb );
4665 createTool( SMESHOp::OpOrientation, modifyTb );
4666 createTool( SMESHOp::OpReorientFaces, modifyTb );
4667 createTool( SMESHOp::OpMoveNode, modifyTb );
4668 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4669 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4670 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4671 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4672 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4673 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4674 createTool( SMESHOp::OpSmoothing, modifyTb );
4675 createTool( SMESHOp::OpPatternMapping, modifyTb );
4677 // Adaptation - begin
4678 #ifndef DISABLE_MG_ADAPT
4679 int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
4680 createTool( SMESHOp::OpMGAdapt, adaptTb );
4684 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4685 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4687 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4688 createTool( SMESHOp::OpUpdate, dispModeTb );
4690 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4691 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4695 OB = "'ObjectBrowser'",
4696 View = "'" + SVTK_Viewer::Type() + "'",
4698 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4699 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4700 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4701 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4702 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4703 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4704 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4705 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4706 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4707 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4708 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4709 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4711 mesh_part = mesh + " " + subMesh + " " + group,
4712 mesh_group = mesh + " " + group,
4713 mesh_submesh = mesh + " " + subMesh,
4714 hyp_alg = hypo + " " + algo;
4716 // popup for object browser
4718 isInvisible("not( isVisible )"),
4719 isEmpty("numberOfNodes = 0"),
4720 isNotEmpty("numberOfNodes <> 0"),
4722 // has nodes, edges, etc in VISIBLE! actor
4723 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4724 hasElems("(count( elemTypes ) > 0)"),
4725 hasDifferentElems("(count( elemTypes ) > 1)"),
4726 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4727 hasBalls("({'BallElem'} in elemTypes)"),
4728 hasElems0d("({'Elem0d'} in elemTypes)"),
4729 hasEdges("({'Edge'} in elemTypes)"),
4730 hasFaces("({'Face'} in elemTypes)"),
4731 hasVolumes("({'Volume'} in elemTypes)"),
4732 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4734 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4735 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4736 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4737 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4738 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4739 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4741 popupMgr()->insert( separator(), -1, 0 );
4742 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4743 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4744 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4745 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4746 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4747 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4748 popupMgr()->insert( separator(), -1, 0 );
4749 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4750 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4751 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4752 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4753 popupMgr()->insert( separator(), -1, 0 );
4754 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4755 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4756 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4757 popupMgr()->insert( separator(), -1, 0 );
4758 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4759 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4760 popupMgr()->insert( separator(), -1, 0 );
4761 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4762 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4764 // Adaptation - begin
4765 #ifndef DISABLE_MG_ADAPT
4766 popupMgr()->insert( separator(), -1, 0 );
4767 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4768 popupMgr()->insert( separator(), -1, 0 );
4772 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4773 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4774 QString only_one_2D = only_one_non_empty + " && dim>1";
4776 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4777 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4778 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4779 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4780 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4782 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4784 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4785 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4786 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4788 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4789 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4790 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4791 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4793 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4795 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4796 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4797 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4798 popupMgr()->insert( separator(), -1, 0 );
4800 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4801 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4802 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4805 createPopupItem( SMESHOp::OpEditGroup, View, group );
4806 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4807 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4809 popupMgr()->insert( separator(), -1, 0 );
4810 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4811 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4812 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4813 popupMgr()->insert( separator(), -1, 0 );
4815 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4816 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4817 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4818 popupMgr()->insert( separator(), -1, 0 );
4820 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4821 QString aType = QString( "%1type in {%2}" ).arg( lc );
4822 aType = aType.arg( mesh_part );
4823 QString aMeshInVTK = aClient + "&&" + aType;
4825 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4826 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4827 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4829 //-------------------------------------------------
4831 //-------------------------------------------------
4832 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4834 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4835 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4836 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4838 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4839 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4840 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4842 popupMgr()->insert( separator(), -1, -1 );
4844 //-------------------------------------------------
4846 //-------------------------------------------------
4847 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4849 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4850 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4851 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4853 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4854 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4855 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4857 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4858 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4859 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4861 popupMgr()->insert( separator(), anId, -1 );
4863 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4864 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4865 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4867 //-------------------------------------------------
4869 //-------------------------------------------------
4870 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4872 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4874 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4875 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4876 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4878 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4879 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4880 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4882 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4883 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4884 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4886 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4887 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4888 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4890 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4891 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4892 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4894 popupMgr()->insert( separator(), anId, -1 );
4896 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4897 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4899 popupMgr()->insert( separator(), anId, -1 );
4901 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4902 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4905 //-------------------------------------------------
4906 // Representation of the 2D Quadratic elements
4907 //-------------------------------------------------
4908 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4909 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4910 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4911 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4913 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4914 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4915 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4917 //-------------------------------------------------
4918 // Orientation of faces
4919 //-------------------------------------------------
4920 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4921 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4922 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4924 //-------------------------------------------------
4926 //-------------------------------------------------
4927 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4928 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4930 //-------------------------------------------------
4932 //-------------------------------------------------
4933 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4934 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4936 //-------------------------------------------------
4938 //-------------------------------------------------
4940 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4941 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4942 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4943 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4945 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4947 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4948 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4950 popupMgr()->insert( separator(), anId, -1 );
4952 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4954 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4955 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4956 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4958 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4959 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4960 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4962 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4963 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4964 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4966 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4968 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4969 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4970 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4972 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4973 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4974 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4977 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4978 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4979 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4980 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4983 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4985 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4986 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4987 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4989 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4990 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4991 QtxPopupMgr::VisibleRule );
4992 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4994 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4995 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4996 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4998 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4999 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5000 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
5002 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
5003 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5004 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
5006 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
5007 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5008 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
5010 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
5011 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5012 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5014 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5015 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5016 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5018 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5019 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5020 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5022 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5023 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5024 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5026 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5027 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5028 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5030 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5031 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5032 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5034 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5035 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5036 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5038 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5039 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5040 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5042 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5043 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5044 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5046 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5048 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5049 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5050 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5052 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5053 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5054 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5056 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5057 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5058 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5060 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5061 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5062 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5064 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5065 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5066 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5068 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5069 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5070 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5072 popupMgr()->insert( separator(), anId, -1 );
5074 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5075 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5076 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5077 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5078 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5080 popupMgr()->insert( separator(), anId, -1 );
5082 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5084 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5085 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5087 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5088 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5089 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5091 #ifndef DISABLE_PLOT2DVIEWER
5092 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5093 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5096 //-------------------------------------------------
5098 //-------------------------------------------------
5099 popupMgr()->insert( separator(), -1, -1 );
5100 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5101 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5102 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5103 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5105 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5106 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5108 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5109 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5111 popupMgr()->insert( separator(), -1, -1 );
5113 //-------------------------------------------------
5115 //-------------------------------------------------
5116 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5117 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5119 popupMgr()->insert( separator(), -1, -1 );
5121 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5122 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5123 popupMgr()->insert( separator(), -1, -1 );
5125 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5126 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5128 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5129 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5131 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5132 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5135 //================================================================================
5137 * \brief Return true if SMESH or GEOM objects are selected.
5138 * Is called form LightApp_Module::activateModule() which clear selection if
5139 * not isSelectionCompatible()
5141 //================================================================================
5143 bool SMESHGUI::isSelectionCompatible()
5145 bool isCompatible = true;
5146 SALOME_ListIO selected;
5147 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5148 Sel->selectedObjects( selected );
5150 SALOME_ListIteratorOfListIO It( selected );
5151 for ( ; isCompatible && It.More(); It.Next())
5153 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5154 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5155 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5157 return isCompatible;
5161 bool SMESHGUI::reusableOperation( const int id )
5163 // compute, evaluate and precompute are not reusable operations
5164 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5169 QString wrap(const QString& text, const QString& tag)
5170 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5173 bool SMESHGUI::activateModule( SUIT_Study* study )
5175 bool res = SalomeApp_Module::activateModule( study );
5177 setMenuShown( true );
5178 setToolShown( true );
5180 // Fill in Help Panel
5181 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5182 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5184 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5187 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5188 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5189 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5190 lab = lab + tr("INFO_REFINE") + ":";
5191 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5192 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5193 lab = lab + wrap(items.join(""), "ul");
5196 app->infoPanel()->addLabel(lab, gb);
5198 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5199 items << wrap("UNV", "li")
5200 << wrap("MED", "li")
5201 << wrap("STL", "li")
5202 << wrap("CGNS", "li")
5203 << wrap("SAUV", "li")
5204 << wrap("GMF", "li");
5205 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5208 app->infoPanel()->addLabel(lab, gb);
5210 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5211 lab = tr("INFO_DISPLAY") + "<br/>";
5212 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5213 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5214 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5215 << wrap("...", "li");
5216 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5218 lab = lab + tr("INFO_CLIPPING");
5220 app->infoPanel()->addLabel(lab, gb);
5223 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5224 PyGILState_STATE gstate = PyGILState_Ensure();
5225 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5226 if ( !pluginsmanager ) {
5230 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5235 PyGILState_Release(gstate);
5236 // end of SMESH plugins loading
5238 // Reset actions accelerator keys
5239 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5241 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5242 GetSMESHGen()->UpdateStudy();
5244 // get all view currently opened in the study and connect their signals to
5245 // the corresponding slots of the class.
5246 SUIT_Desktop* aDesk = study->application()->desktop();
5248 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5249 SUIT_ViewWindow* wnd;
5250 foreach ( wnd, wndList )
5254 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5255 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5261 Py_XDECREF(pluginsmanager);
5265 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5267 setMenuShown( false );
5268 setToolShown( false );
5270 EmitSignalCloseAllDialogs();
5272 // Unset actions accelerator keys
5273 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5275 return SalomeApp_Module::deactivateModule( study );
5278 void SMESHGUI::studyClosed( SUIT_Study* s )
5282 SMESH::RemoveVisuData();
5283 SalomeApp_Module::studyClosed( s );
5286 void SMESHGUI::OnGUIEvent()
5288 const QObject* obj = sender();
5289 if ( !obj || !obj->inherits( "QAction" ) )
5291 int id = actionId((QAction*)obj);
5296 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5298 if ( CORBA::is_nil( myComponentSMESH ) )
5300 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5301 return aGUI.myComponentSMESH;
5303 return myComponentSMESH;
5306 QString SMESHGUI::engineIOR() const
5308 CORBA::ORB_var anORB = getApp()->orb();
5309 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5310 return QString( anIOR.in() );
5313 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5315 SalomeApp_Module::contextMenuPopup( client, menu, title );
5317 selectionMgr()->selectedObjects( lst );
5318 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5319 Handle(SALOME_InteractiveObject) io = lst.First();
5320 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5321 _PTR(Study) study = appStudy->studyDS();
5322 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5324 QString aName = SMESH::fromUtf8( obj->GetName());
5325 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5326 aName.remove(( aName.length() - 1 ), 1 );
5332 LightApp_Selection* SMESHGUI::createSelection() const
5334 return new SMESHGUI_Selection();
5337 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5339 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5340 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5341 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5342 #ifndef DISABLE_PYCONSOLE
5343 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5347 void SMESHGUI::viewManagers( QStringList& list ) const
5349 list.append( SVTK_Viewer::Type() );
5352 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5354 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5355 SMESH::UpdateSelectionProp( this );
5357 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5358 for(int i = 0; i < aViews.count() ; i++){
5359 SUIT_ViewWindow *sf = aViews[i];
5362 EmitSignalActivatedViewManager();
5366 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5368 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5369 myClippingPlaneInfoMap.erase( theViewManager );
5372 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5374 theActor->AddObserver( SMESH::DeleteActorEvent,
5375 myEventCallbackCommand.GetPointer(),
5379 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5380 unsigned long theEvent,
5381 void* theClientData,
5382 void* /*theCallData*/ )
5384 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5385 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5386 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5387 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5388 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5389 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5390 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5391 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5392 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5393 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5394 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5395 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5396 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5397 if( anActor == *anIter3 ) {
5398 anActorList.erase( anIter3 );
5409 void SMESHGUI::createPreferences()
5411 // General tab ------------------------------------------------------------------------
5412 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5414 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5415 setPreferenceProperty( autoUpdate, "columns", 2 );
5416 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5417 setPreferenceProperty( lim, "min", 0 );
5418 setPreferenceProperty( lim, "max", 100000000 );
5419 setPreferenceProperty( lim, "step", 1000 );
5420 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5421 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5423 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5424 setPreferenceProperty( dispgroup, "columns", 2 );
5426 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5428 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5430 modes.append( tr("MEN_WIRE") );
5431 modes.append( tr("MEN_SHADE") );
5432 modes.append( tr("MEN_NODES") );
5433 modes.append( tr("MEN_SHRINK") );
5434 QList<QVariant> indices;
5435 indices.append( 0 );
5436 indices.append( 1 );
5437 indices.append( 2 );
5438 indices.append( 3 );
5439 setPreferenceProperty( dispmode, "strings", modes );
5440 setPreferenceProperty( dispmode, "indexes", indices );
5442 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5443 setPreferenceProperty( arcgroup, "columns", 2 );
5444 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5445 QStringList quadraticModes;
5446 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5447 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5449 indices.append( 0 );
5450 indices.append( 1 );
5451 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5452 setPreferenceProperty( quadraticmode, "indexes", indices );
5454 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5455 "SMESH", "max_angle" );
5456 setPreferenceProperty( maxAngle, "min", 1 );
5457 setPreferenceProperty( maxAngle, "max", 90 );
5459 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5460 setPreferenceProperty( qaGroup, "columns", 2 );
5461 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5462 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5463 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5464 setPreferenceProperty( prec, "min", 0 );
5465 setPreferenceProperty( prec, "max", 100 );
5466 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5467 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5468 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5469 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5470 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5473 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5474 setPreferenceProperty( cinc, "min", 0 );
5475 setPreferenceProperty( cinc, "max", 5 );
5478 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5479 setPreferenceProperty( exportgroup, "columns", 2 );
5480 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5481 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5482 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5483 setPreferenceProperty( zTol, "precision", 10 );
5484 setPreferenceProperty( zTol, "min", 0.0000000001 );
5485 setPreferenceProperty( zTol, "max", 1000000.0 );
5486 setPreferenceProperty( zTol, "step", 1. );
5487 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5489 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5490 setPreferenceProperty( computeGroup, "columns", 2 );
5491 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5493 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5494 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5495 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5497 indices.append( 0 );
5498 indices.append( 1 );
5499 indices.append( 2 );
5500 setPreferenceProperty( notifyMode, "strings", modes );
5501 setPreferenceProperty( notifyMode, "indexes", indices );
5503 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5504 setPreferenceProperty( infoGroup, "columns", 2 );
5505 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5507 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5508 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5510 indices.append( 0 );
5511 indices.append( 1 );
5512 setPreferenceProperty( elemInfo, "strings", modes );
5513 setPreferenceProperty( elemInfo, "indexes", indices );
5514 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5515 setPreferenceProperty( nodesLim, "min", 0 );
5516 setPreferenceProperty( nodesLim, "max", 10000000 );
5517 setPreferenceProperty( nodesLim, "step", 10000 );
5518 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5519 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5520 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5521 setPreferenceProperty( ctrlLim, "min", 0 );
5522 setPreferenceProperty( ctrlLim, "max", 10000000 );
5523 setPreferenceProperty( ctrlLim, "step", 1000 );
5524 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5525 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5526 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5527 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5528 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5530 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5531 setPreferenceProperty( segGroup, "columns", 2 );
5532 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5533 "SMESH", "segmentation" );
5534 setPreferenceProperty( segLen, "min", 1 );
5535 setPreferenceProperty( segLen, "max", 10000000 );
5536 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5537 "SMESH", "nb_segments_per_edge" );
5538 setPreferenceProperty( nbSeg, "min", 1 );
5539 setPreferenceProperty( nbSeg, "max", 10000000 );
5540 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5542 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5543 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5544 "SMESH", "forget_mesh_on_hyp_modif" );
5547 // Quantities with individual precision settings
5548 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5549 setPreferenceProperty( precGroup, "columns", 2 );
5551 const int nbQuantities = 6;
5552 int precs[nbQuantities], ii = 0;
5553 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5554 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5555 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5556 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5557 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5558 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5559 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5560 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5561 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5562 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5563 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5564 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5566 // Set property for precision value for spinboxes
5567 for ( ii = 0; ii < nbQuantities; ii++ ){
5568 setPreferenceProperty( precs[ii], "min", -14 );
5569 setPreferenceProperty( precs[ii], "max", 14 );
5570 setPreferenceProperty( precs[ii], "precision", 2 );
5573 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5574 setPreferenceProperty( previewGroup, "columns", 2 );
5575 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5576 setPreferenceProperty( chunkSize, "min", 1 );
5577 setPreferenceProperty( chunkSize, "max", 1000 );
5578 setPreferenceProperty( chunkSize, "step", 50 );
5580 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5581 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5583 // Mesh tab ------------------------------------------------------------------------
5584 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5585 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5586 setPreferenceProperty( nodeGroup, "columns", 3 );
5588 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5590 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5592 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5593 QList<QVariant> aMarkerTypeIndicesList;
5594 QList<QVariant> aMarkerTypeIconsList;
5595 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5596 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5597 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5598 aMarkerTypeIndicesList << i;
5599 aMarkerTypeIconsList << pixmap;
5601 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5602 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5604 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5606 QList<QVariant> aMarkerScaleIndicesList;
5607 QStringList aMarkerScaleValuesList;
5608 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5609 aMarkerScaleIndicesList << i;
5610 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5611 aMarkerScaleValuesList << QString::number( i );
5613 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5614 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5616 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5617 //setPreferenceProperty( elemGroup, "columns", 2 );
5619 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5620 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5621 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5622 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5623 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5624 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5625 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5626 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5627 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5630 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5631 setPreferenceProperty( grpGroup, "columns", 2 );
5633 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5634 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5636 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5637 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5638 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5639 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5640 int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5641 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5642 int ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5643 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5644 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5645 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5646 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5647 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5648 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5649 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5651 setPreferenceProperty( size0d, "min", 1 );
5652 setPreferenceProperty( size0d, "max", 10 );
5654 // setPreferenceProperty( ballSize, "min", 1 );
5655 // setPreferenceProperty( ballSize, "max", 10 );
5657 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5658 setPreferenceProperty( ballDiameter, "max", 1e9 );
5659 setPreferenceProperty( ballDiameter, "step", 0.1 );
5661 setPreferenceProperty( ballScale, "min", 1e-2 );
5662 setPreferenceProperty( ballScale, "max", 1e7 );
5663 setPreferenceProperty( ballScale, "step", 0.5 );
5665 setPreferenceProperty( elemW, "min", 1 );
5666 setPreferenceProperty( elemW, "max", 5 );
5668 setPreferenceProperty( outW, "min", 1 );
5669 setPreferenceProperty( outW, "max", 5 );
5671 setPreferenceProperty( shrink, "min", 0 );
5672 setPreferenceProperty( shrink, "max", 100 );
5674 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5675 setPreferenceProperty( numGroup, "columns", 2 );
5677 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5678 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5680 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5681 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5683 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5684 setPreferenceProperty( orientGroup, "columns", 1 );
5686 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5687 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5689 setPreferenceProperty( orientScale, "min", 0.05 );
5690 setPreferenceProperty( orientScale, "max", 0.5 );
5691 setPreferenceProperty( orientScale, "step", 0.05 );
5693 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5695 // Selection tab ------------------------------------------------------------------------
5696 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5698 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5699 setPreferenceProperty( selGroup, "columns", 2 );
5701 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5702 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5704 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5705 setPreferenceProperty( preGroup, "columns", 2 );
5707 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5709 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5710 setPreferenceProperty( precSelGroup, "columns", 2 );
5712 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5713 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5714 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5716 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5717 setPreferenceProperty( sinc, "min", 0 );
5718 setPreferenceProperty( sinc, "max", 5 );
5720 // Scalar Bar tab ------------------------------------------------------------------------
5721 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5722 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5723 setPreferenceProperty( fontGr, "columns", 2 );
5725 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5726 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5728 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5729 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5731 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5732 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5734 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5735 setPreferenceProperty( numcol, "min", 2 );
5736 setPreferenceProperty( numcol, "max", 256 );
5738 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5739 setPreferenceProperty( numlab, "min", 2 );
5740 setPreferenceProperty( numlab, "max", 65 );
5742 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5743 setPreferenceProperty( orientGr, "columns", 2 );
5744 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5745 QStringList orients;
5746 orients.append( tr( "SMESH_VERTICAL" ) );
5747 orients.append( tr( "SMESH_HORIZONTAL" ) );
5748 indices.clear(); indices.append( 0 ); indices.append( 1 );
5749 setPreferenceProperty( orient, "strings", orients );
5750 setPreferenceProperty( orient, "indexes", indices );
5752 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5753 setPreferenceProperty( posVSizeGr, "columns", 2 );
5754 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5755 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5756 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5757 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5758 setPreferenceProperty( xv, "step", 0.1 );
5759 setPreferenceProperty( xv, "min", 0.0 );
5760 setPreferenceProperty( xv, "max", 1.0 );
5761 setPreferenceProperty( yv, "step", 0.1 );
5762 setPreferenceProperty( yv, "min", 0.0 );
5763 setPreferenceProperty( yv, "max", 1.0 );
5764 setPreferenceProperty( wv, "step", 0.1 );
5765 setPreferenceProperty( wv, "min", 0.0 );
5766 setPreferenceProperty( wv, "max", 1.0 );
5767 setPreferenceProperty( hv, "min", 0.0 );
5768 setPreferenceProperty( hv, "max", 1.0 );
5769 setPreferenceProperty( hv, "step", 0.1 );
5771 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5772 setPreferenceProperty( posHSizeGr, "columns", 2 );
5773 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5774 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5775 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5776 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5777 setPreferenceProperty( xv, "min", 0.0 );
5778 setPreferenceProperty( xv, "max", 1.0 );
5779 setPreferenceProperty( xv, "step", 0.1 );
5780 setPreferenceProperty( xh, "min", 0.0 );
5781 setPreferenceProperty( xh, "max", 1.0 );
5782 setPreferenceProperty( xh, "step", 0.1 );
5783 setPreferenceProperty( yh, "min", 0.0 );
5784 setPreferenceProperty( yh, "max", 1.0 );
5785 setPreferenceProperty( yh, "step", 0.1 );
5786 setPreferenceProperty( wh, "min", 0.0 );
5787 setPreferenceProperty( wh, "max", 1.0 );
5788 setPreferenceProperty( wh, "step", 0.1 );
5789 setPreferenceProperty( hh, "min", 0.0 );
5790 setPreferenceProperty( hh, "max", 1.0 );
5791 setPreferenceProperty( hh, "step", 0.1 );
5793 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5794 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5795 setPreferenceProperty( distributionGr, "columns", 3 );
5797 types.append( tr( "SMESH_MONOCOLOR" ) );
5798 types.append( tr( "SMESH_MULTICOLOR" ) );
5799 indices.clear(); indices.append( 0 ); indices.append( 1 );
5800 setPreferenceProperty( coloringType, "strings", types );
5801 setPreferenceProperty( coloringType, "indexes", indices );
5802 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5804 // Adaptation - begin
5805 #ifndef DISABLE_MG_ADAPT
5806 // Adaptation tab ------------------------------------------------------------------------
5807 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5810 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5811 setPreferenceProperty( bloc, "columns", 1 );
5812 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5813 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5814 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5815 QStringList aListOfSizeMap;
5816 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5817 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5818 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5819 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5820 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5821 QStringList aListOfTimeStep;
5822 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5823 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5824 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5825 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5830 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5832 if ( sect=="SMESH" ) {
5833 double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5834 double aTol = 1.00000009999999;
5835 std::string aWarning;
5836 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5838 if ( name == "selection_object_color" ||
5839 name == "selection_element_color" ||
5840 name == "highlight_color" ||
5841 name == "selection_precision_node" ||
5842 name == "selection_precision_element" ||
5843 name == "selection_precision_object" ||
5844 name == "selection_increment")
5846 SMESH::UpdateSelectionProp( this );
5848 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5850 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5851 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5852 if ( sbX1+sbW > aTol ) {
5853 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5856 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5857 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5860 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5862 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5863 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5864 if ( sbY1 + sbH > aTol ) {
5865 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5866 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5867 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5870 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5872 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5873 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5874 if ( sbX1 + sbW > aTol ) {
5875 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5878 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5879 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5882 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5884 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5885 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5886 if ( sbY1 + sbH > aTol ) {
5887 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5890 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5891 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5894 else if ( name == "segmentation" )
5896 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5897 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5899 else if ( name == "nb_segments_per_edge" )
5901 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5902 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5904 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5906 QString val = aResourceMgr->stringValue( "SMESH", name );
5907 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5909 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5911 SMESH::UpdateFontProp( this );
5913 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5915 SMESH::UpdateFontProp( this );
5918 if ( aWarning.size() != 0 ) {
5919 aWarning += "The default values are applied instead.";
5920 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5921 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5922 QObject::tr(aWarning.c_str()));
5927 //================================================================================
5929 * \brief Update something in accordance with update flags
5930 * \param theFlags - update flags
5932 * Update viewer or/and object browser etc. in accordance with update flags ( see
5933 * LightApp_UpdateFlags enumeration ).
5935 //================================================================================
5936 void SMESHGUI::update( const int flags )
5938 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5939 SMESH::UpdateView();
5941 SalomeApp_Module::update( flags );
5944 //================================================================================
5946 * \brief Set default selection mode
5948 * SLOT called when operation committed. Sets default selection mode
5950 //================================================================================
5951 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5953 SVTK_ViewWindow* vtkWnd =
5954 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5956 vtkWnd->SetSelectionMode( ActorSelection );
5959 //================================================================================
5961 * \brief Set default selection mode
5963 * SLOT called when operation aborted. Sets default selection mode
5965 //================================================================================
5966 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5968 SVTK_ViewWindow* vtkWnd =
5969 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5971 vtkWnd->SetSelectionMode( ActorSelection );
5974 //================================================================================
5976 * \brief Creates operation with given identifier
5977 * \param id - identifier of operation to be started
5978 * \return Pointer on created operation or NULL if operation is not created
5980 * Virtual method redefined from the base class creates operation with given id.
5981 * It is called called automatically from startOperation method of base class.
5983 //================================================================================
5984 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5986 LightApp_Operation* op = 0;
5987 // to do : create operation here
5990 case SMESHOp::OpSplitBiQuadratic:
5991 op = new SMESHGUI_SplitBiQuadOp();
5993 case SMESHOp::OpConvertMeshToQuadratic:
5994 op = new SMESHGUI_ConvToQuadOp();
5996 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5997 op = new SMESHGUI_Make2DFrom3DOp();
5999 case SMESHOp::OpReorientFaces:
6000 op = new SMESHGUI_ReorientFacesOp();
6002 case SMESHOp::OpCreateMesh:
6003 op = new SMESHGUI_MeshOp( true, true );
6005 case SMESHOp::OpCreateSubMesh:
6006 op = new SMESHGUI_MeshOp( true, false );
6008 case SMESHOp::OpEditMeshOrSubMesh:
6009 case SMESHOp::OpEditMesh:
6010 case SMESHOp::OpEditSubMesh:
6011 op = new SMESHGUI_MeshOp( false );
6013 case SMESHOp::OpCompute:
6014 case SMESHOp::OpComputeSubMesh:
6015 op = new SMESHGUI_ComputeOp();
6017 case SMESHOp::OpShowErrors:
6018 op = new SMESHGUI_ShowErrorsOp();
6020 case SMESHOp::OpPreCompute:
6021 op = new SMESHGUI_PrecomputeOp();
6023 case SMESHOp::OpEvaluate:
6024 op = new SMESHGUI_EvaluateOp();
6026 case SMESHOp::OpMeshOrder:
6027 op = new SMESHGUI_MeshOrderOp();
6029 case SMESHOp::OpCreateGeometryGroup:
6030 op = new SMESHGUI_GroupOnShapeOp();
6032 case SMESHOp::OpFindElementByPoint:
6033 op = new SMESHGUI_FindElemByPointOp();
6035 case SMESHOp::OpMoveNode: // Make mesh pass through point
6036 op = new SMESHGUI_MakeNodeAtPointOp();
6038 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6039 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6046 op = SalomeApp_Module::createOperation( id );
6050 //================================================================================
6052 * \brief Stops current operations and starts a given one
6053 * \param id - The id of the operation to start
6055 //================================================================================
6057 void SMESHGUI::switchToOperation(int id)
6059 activeStudy()->abortAllOperations();
6060 startOperation( id );
6063 LightApp_Displayer* SMESHGUI::displayer()
6066 myDisplayer = new SMESHGUI_Displayer( getApp() );
6070 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6073 int aTolerance = 64;
6074 int anIterations = 0;
6080 if( anIterations % aPeriod == 0 )
6083 if( aTolerance < 1 )
6087 aHue = (int)( 360.0 * rand() / RAND_MAX );
6090 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6091 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6092 for( ; it != itEnd; ++it )
6094 SALOMEDS::Color anAutoColor = *it;
6095 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6098 aQColor.getHsv( &h, &s, &v );
6099 if( abs( h - aHue ) < aTolerance )
6111 aColor.setHsv( aHue, 255, 255 );
6113 SALOMEDS::Color aSColor;
6114 aSColor.R = aColor.redF();
6115 aSColor.G = aColor.greenF();
6116 aSColor.B = aColor.blueF();
6121 const char* gSeparator = "_"; // character used to separate parameter names
6122 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6123 const char* gPathSep = "|"; // character used to separate paths
6126 * \brief Store visual parameters
6128 * This method is called just before the study document is saved.
6129 * Store visual parameters in AttributeParameter attribute(s)
6131 void SMESHGUI::storeVisualParameters (int savePoint)
6134 Kernel_Utils::Localizer loc;
6136 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6137 if (!appStudy || !appStudy->studyDS())
6139 _PTR(Study) studyDS = appStudy->studyDS();
6141 // componentName is used for encoding of entries when storing them in IParameters
6142 std::string componentName = myComponentSMESH->ComponentDataType();
6143 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6144 //if (!aSComponent) return;
6147 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6148 componentName.c_str(),
6150 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6152 // store custom markers
6153 if( !myMarkerMap.empty() )
6155 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6156 for( ; anIter != myMarkerMap.end(); anIter++ )
6158 int anId = anIter->first;
6159 VTK::MarkerData aMarkerData = anIter->second;
6160 std::string aMarkerFileName = aMarkerData.first;
6161 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6162 if( aMarkerTexture.size() < 3 )
6163 continue; // should contain at least width, height and the first value
6165 QString aPropertyName( "texture" );
6166 aPropertyName += gSeparator;
6167 aPropertyName += QString::number( anId );
6169 QString aPropertyValue = aMarkerFileName.c_str();
6170 aPropertyValue += gPathSep;
6172 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6173 ushort aWidth = *aTextureIter++;
6174 ushort aHeight = *aTextureIter++;
6175 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6176 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6177 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6178 aPropertyValue += QString::number( *aTextureIter );
6180 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6184 // viewers counters are used for storing view_numbers in IParameters
6187 // main cycle to store parameters of displayed objects
6188 QList<SUIT_ViewManager*> lst;
6189 QList<SUIT_ViewManager*>::Iterator it;
6190 getApp()->viewManagers(lst);
6191 for (it = lst.begin(); it != lst.end(); it++)
6193 SUIT_ViewManager* vman = *it;
6194 QString vType = vman->getType();
6196 // saving VTK actors properties
6197 if (vType == SVTK_Viewer::Type())
6199 // store the clipping planes attached to the view manager
6200 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6201 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6202 if( anIter != myClippingPlaneInfoMap.end() )
6203 aClippingPlaneInfoList = anIter->second;
6205 if( !aClippingPlaneInfoList.empty() ) {
6206 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6207 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6209 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6210 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6212 QString aPropertyName( "ClippingPlane" );
6213 aPropertyName += gSeparator;
6214 aPropertyName += QString::number( vtkViewers );
6215 aPropertyName += gSeparator;
6216 aPropertyName += QString::number( anId );
6218 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6219 aPropertyValue += gDigitsSep;
6220 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6221 aPropertyValue += gDigitsSep;
6222 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6223 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6224 aPropertyValue += gDigitsSep;
6225 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6226 aPropertyValue += gDigitsSep;
6227 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6228 aPropertyValue += gDigitsSep;
6229 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6230 aPropertyValue += gDigitsSep;
6231 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6232 aPropertyValue += gDigitsSep;
6233 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6234 aPropertyValue += gDigitsSep;
6235 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6237 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6238 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6239 aPropertyValue += gDigitsSep;
6240 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6241 aPropertyValue += gDigitsSep;
6242 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6243 aPropertyValue += gDigitsSep;
6244 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6247 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6251 QVector<SUIT_ViewWindow*> views = vman->getViews();
6252 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6254 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6256 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6257 vtkActorCollection* allActors = aCopy.GetActors();
6258 allActors->InitTraversal();
6259 while (vtkActor* actor = allActors->GetNextActor())
6261 if (actor->GetVisibility()) // store only visible actors
6263 SMESH_Actor* aSmeshActor = 0;
6264 if (actor->IsA("SMESH_Actor"))
6265 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6266 if (aSmeshActor && aSmeshActor->hasIO())
6268 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6271 // entry is "encoded" = it does NOT contain component address,
6272 // since it is a subject to change on next component loading
6273 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6275 std::string param, vtkParam = vType.toLatin1().data();
6276 vtkParam += gSeparator;
6277 vtkParam += QString::number(vtkViewers).toLatin1().data();
6278 vtkParam += gSeparator;
6281 param = vtkParam + "Visibility";
6282 ip->setParameter(entry, param, "On");
6285 param = vtkParam + "Representation";
6286 ip->setParameter(entry, param, QString::number
6287 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6290 param = vtkParam + "IsShrunk";
6291 ip->setParameter(entry, param, QString::number
6292 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6294 // Displayed entities
6295 unsigned int aMode = aSmeshActor->GetEntityMode();
6296 bool isE = aMode & SMESH_Actor::eEdges;
6297 bool isF = aMode & SMESH_Actor::eFaces;
6298 bool isV = aMode & SMESH_Actor::eVolumes;
6299 bool is0d = aMode & SMESH_Actor::e0DElements;
6300 bool isB = aMode & SMESH_Actor::eBallElem;
6302 QString modeStr ("e");
6303 modeStr += gDigitsSep; modeStr += QString::number(isE);
6304 modeStr += gDigitsSep; modeStr += "f";
6305 modeStr += gDigitsSep; modeStr += QString::number(isF);
6306 modeStr += gDigitsSep; modeStr += "v";
6307 modeStr += gDigitsSep; modeStr += QString::number(isV);
6308 modeStr += gDigitsSep; modeStr += "0d";
6309 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6310 modeStr += gDigitsSep; modeStr += "b";
6311 modeStr += gDigitsSep; modeStr += QString::number(isB);
6313 param = vtkParam + "Entities";
6314 ip->setParameter(entry, param, modeStr.toLatin1().data());
6320 aSmeshActor->GetSufaceColor(r, g, b, delta);
6321 QStringList colorStr;
6322 colorStr << "surface";
6323 colorStr << QString::number(r);
6324 colorStr << QString::number(g);
6325 colorStr << QString::number(b);
6327 colorStr << "backsurface";
6328 colorStr << QString::number(delta);
6330 aSmeshActor->GetVolumeColor(r, g, b, delta);
6331 colorStr << "volume";
6332 colorStr << QString::number(r);
6333 colorStr << QString::number(g);
6334 colorStr << QString::number(b);
6335 colorStr << QString::number(delta);
6337 aSmeshActor->GetEdgeColor(r, g, b);
6339 colorStr << QString::number(r);
6340 colorStr << QString::number(g);
6341 colorStr << QString::number(b);
6343 aSmeshActor->GetNodeColor(r, g, b);
6345 colorStr << QString::number(r);
6346 colorStr << QString::number(g);
6347 colorStr << QString::number(b);
6349 aSmeshActor->GetOutlineColor(r, g, b);
6350 colorStr << "outline";
6351 colorStr << QString::number(r);
6352 colorStr << QString::number(g);
6353 colorStr << QString::number(b);
6355 aSmeshActor->Get0DColor(r, g, b);
6356 colorStr << "elem0d";
6357 colorStr << QString::number(r);
6358 colorStr << QString::number(g);
6359 colorStr << QString::number(b);
6361 aSmeshActor->GetBallColor(r, g, b);
6363 colorStr << QString::number(r);
6364 colorStr << QString::number(g);
6365 colorStr << QString::number(b);
6367 aSmeshActor->GetFacesOrientationColor(r, g, b);
6368 colorStr << "orientation";
6369 colorStr << QString::number(r);
6370 colorStr << QString::number(g);
6371 colorStr << QString::number(b);
6373 param = vtkParam + "Colors";
6374 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6377 QStringList sizeStr;
6379 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6380 sizeStr << "outline";
6381 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6382 sizeStr << "elem0d";
6383 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6385 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6386 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6387 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6388 sizeStr << "shrink";
6389 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6390 sizeStr << "orientation";
6391 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6392 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6394 param = vtkParam + "Sizes";
6395 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6400 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6401 if( aMarkerType == VTK::MT_USER ) {
6402 markerStr += "custom";
6403 markerStr += gDigitsSep;
6404 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6408 markerStr += gDigitsSep;
6409 markerStr += QString::number( (int)aMarkerType );
6410 markerStr += gDigitsSep;
6411 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6414 param = vtkParam + "PointMarker";
6415 ip->setParameter(entry, param, markerStr.toLatin1().data());
6418 param = vtkParam + "Opacity";
6419 ip->setParameter(entry, param,
6420 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6423 param = vtkParam + "ClippingPlane";
6425 if( !aClippingPlaneInfoList.empty() ) {
6426 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6427 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6429 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6430 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6431 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6432 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6433 if( aSmeshActor == *anIter2 ) {
6434 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6435 QString::number( anId ).toLatin1().constData() );
6442 ip->setParameter( entry, param, "Off" );
6443 } // if (io->hasEntry())
6444 } // SMESH_Actor && hasIO
6446 } // while.. actors traversal
6450 } // if (SVTK view model)
6451 } // for (viewManagers)
6454 // data structures for clipping planes processing
6458 bool isOpenGLClipping;
6459 vtkIdType RelativeOrientation;
6462 int AbsoluteOrientation;
6463 double X, Y, Z, Dx, Dy, Dz;
6465 typedef std::list<TPlaneData> TPlaneDataList;
6466 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6468 typedef std::list<vtkActor*> TActorList;
6471 TActorList ActorList;
6472 SUIT_ViewManager* ViewManager;
6474 typedef std::list<TPlaneInfo> TPlaneInfoList;
6475 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6478 * \brief Restore visual parameters
6480 * This method is called after the study document is opened.
6481 * Restore visual parameters from AttributeParameter attribute(s)
6483 void SMESHGUI::restoreVisualParameters (int savePoint)
6486 Kernel_Utils::Localizer loc;
6488 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6489 if (!appStudy || !appStudy->studyDS())
6491 _PTR(Study) studyDS = appStudy->studyDS();
6493 // componentName is used for encoding of entries when storing them in IParameters
6494 std::string componentName = myComponentSMESH->ComponentDataType();
6497 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6498 componentName.c_str(),
6500 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6502 // restore custom markers and map of clipping planes
6503 TPlaneDataMap aPlaneDataMap;
6505 std::vector<std::string> properties = ip->getProperties();
6506 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6508 std::string property = *propIt;
6509 QString aPropertyName( property.c_str() );
6510 QString aPropertyValue( ip->getProperty( property ).c_str() );
6512 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6513 if( aPropertyNameList.isEmpty() )
6516 QString aPropertyType = aPropertyNameList[0];
6517 if( aPropertyType == "texture" )
6519 if( aPropertyNameList.size() != 2 )
6523 int anId = aPropertyNameList[1].toInt( &ok );
6524 if( !ok || anId < 1 )
6527 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6528 if( aPropertyValueList.size() != 2 )
6531 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6532 QString aMarkerTextureString = aPropertyValueList[1];
6533 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6534 if( aMarkerTextureStringList.size() != 3 )
6538 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6543 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6547 VTK::MarkerTexture aMarkerTexture;
6548 aMarkerTexture.push_back( aWidth );
6549 aMarkerTexture.push_back( aHeight );
6551 QString aMarkerTextureData = aMarkerTextureStringList[2];
6552 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6554 QChar aChar = aMarkerTextureData.at( i );
6555 if( aChar.isDigit() )
6556 aMarkerTexture.push_back( aChar.digitValue() );
6559 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6561 else if( aPropertyType == "ClippingPlane" )
6563 if( aPropertyNameList.size() != 3 )
6567 int aViewId = aPropertyNameList[1].toInt( &ok );
6568 if( !ok || aViewId < 0 )
6572 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6573 if( !ok || aClippingPlaneId < 0 )
6576 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6577 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6580 TPlaneData aPlaneData;
6581 aPlaneData.AbsoluteOrientation = false;
6582 aPlaneData.RelativeOrientation = 0;
6583 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6584 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6585 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6587 aPlaneData.Id = aClippingPlaneId;
6590 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6595 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6599 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6602 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6607 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6612 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6617 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6622 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6627 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6632 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6636 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6638 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6643 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6648 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6653 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6658 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6659 aPlaneDataList.push_back( aPlaneData );
6663 TPlaneInfoMap aPlaneInfoMap;
6665 std::vector<std::string> entries = ip->getEntries();
6667 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6669 // entry is a normal entry - it should be "decoded" (setting base address of component)
6670 QString entry (ip->decodeEntry(*entIt).c_str());
6672 // Check that the entry corresponds to a real object in the Study
6673 // as the object may be deleted or modified after the visual state is saved.
6674 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6675 if (!so) continue; //Skip the not existent entry
6677 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6678 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6680 std::vector<std::string>::iterator namesIt = paramNames.begin();
6681 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6683 // actors are stored in a map after displaying of them for
6684 // quicker access in the future: map < viewID to actor >
6685 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6687 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6689 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6690 // '_' is used as separator and should not be used in viewer type or parameter names.
6691 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6692 if (lst.size() != 3)
6695 QString viewerTypStr = lst[0];
6696 QString viewIndexStr = lst[1];
6697 QString paramNameStr = lst[2];
6700 int viewIndex = viewIndexStr.toUInt(&ok);
6701 if (!ok) // bad conversion of view index to integer
6705 if (viewerTypStr == SVTK_Viewer::Type())
6707 SMESH_Actor* aSmeshActor = 0;
6708 if (vtkActors.IsBound(viewIndex))
6709 aSmeshActor = vtkActors.Find(viewIndex);
6711 QList<SUIT_ViewManager*> lst;
6712 getApp()->viewManagers(viewerTypStr, lst);
6714 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6715 SUIT_ViewManager* vman = NULL;
6716 if (viewIndex >= 0 && viewIndex < lst.count())
6717 vman = lst.at(viewIndex);
6719 if (paramNameStr == "Visibility")
6721 if (!aSmeshActor && displayer() && vman)
6723 SUIT_ViewModel* vmodel = vman->getViewModel();
6724 // SVTK view model can be casted to SALOME_View
6725 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6727 // store displayed actor in a temporary map for quicker
6728 // access later when restoring other parameters
6729 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6730 vtkRenderer* Renderer = vtkView->getRenderer();
6731 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6732 vtkActorCollection* theActors = aCopy.GetActors();
6733 theActors->InitTraversal();
6734 bool isFound = false;
6735 vtkActor *ac = theActors->GetNextActor();
6736 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6737 if (ac->IsA("SMESH_Actor")) {
6738 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6739 if (aGeomAc->hasIO()) {
6740 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6741 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6743 vtkActors.Bind(viewIndex, aGeomAc);
6749 } // if (paramNameStr == "Visibility")
6752 // the rest properties "work" with SMESH_Actor
6755 QString val ((*valuesIt).c_str());
6758 if (paramNameStr == "Representation") {
6759 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6762 else if (paramNameStr == "IsShrunk") {
6764 if (!aSmeshActor->IsShrunk())
6765 aSmeshActor->SetShrink();
6768 if (aSmeshActor->IsShrunk())
6769 aSmeshActor->UnShrink();
6772 // Displayed entities
6773 else if (paramNameStr == "Entities") {
6774 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6775 int aEntityMode = SMESH_Actor::eAllEntity;
6776 for ( int i = 0; i < mode.count(); i+=2 ) {
6777 if ( i < mode.count()-1 ) {
6778 QString type = mode[i];
6779 bool val = mode[i+1].toInt();
6780 if ( type == "e" && !val )
6781 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6782 else if ( type == "f" && !val )
6783 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6784 else if ( type == "v" && !val )
6785 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6786 else if ( type == "0d" && !val )
6787 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6788 else if ( type == "b" && !val )
6789 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6792 aSmeshActor->SetEntityMode( aEntityMode );
6795 else if (paramNameStr == "Colors") {
6796 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6803 QColor outlineColor;
6804 QColor orientationColor;
6810 // below lines are required to get default values for delta coefficients
6811 // of backface color for faces and color of reversed volumes
6812 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6813 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6814 for ( int i = 0; i < colors.count(); i++ ) {
6815 QString type = colors[i];
6816 if ( type == "surface" ) {
6817 // face color is set by 3 values r:g:b, where
6818 // - r,g,b - is rgb color components
6819 if ( i+1 >= colors.count() ) break; // format error
6820 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6821 if ( i+2 >= colors.count() ) break; // format error
6822 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6823 if ( i+3 >= colors.count() ) break; // format error
6824 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6825 faceColor.setRgbF( r, g, b );
6828 else if ( type == "backsurface" ) {
6829 // backface color can be defined in several ways
6830 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6831 // - in latest versions, it is set as delta coefficient
6832 bool rgbOk = false, deltaOk;
6833 if ( i+1 >= colors.count() ) break; // format error
6834 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6835 int delta = colors[i+1].toInt( &deltaOk );
6837 if ( i+1 < colors.count() ) // index is shifted to 1
6838 g = colors[i+1].toDouble( &rgbOk );
6839 if ( rgbOk ) i++; // shift index
6840 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6841 b = colors[i+1].toDouble( &rgbOk );
6843 // - as currently there's no way to set directly backsurface color as it was before,
6844 // we ignore old dump where r,g,b triple was set
6845 // - also we check that delta parameter is set properly
6846 if ( !rgbOk && deltaOk )
6849 else if ( type == "volume" ) {
6850 // volume color is set by 4 values r:g:b:delta, where
6851 // - r,g,b - is a normal volume rgb color components
6852 // - delta - is a reversed volume color delta coefficient
6853 if ( i+1 >= colors.count() ) break; // format error
6854 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6855 if ( i+2 >= colors.count() ) break; // format error
6856 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6857 if ( i+3 >= colors.count() ) break; // format error
6858 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6859 if ( i+4 >= colors.count() ) break; // format error
6860 int delta = colors[i+4].toInt( &bOk );
6861 if ( !bOk ) break; // format error
6862 volumeColor.setRgbF( r, g, b );
6866 else if ( type == "edge" ) {
6867 // edge color is set by 3 values r:g:b, where
6868 // - r,g,b - is rgb color components
6869 if ( i+1 >= colors.count() ) break; // format error
6870 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6871 if ( i+2 >= colors.count() ) break; // format error
6872 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6873 if ( i+3 >= colors.count() ) break; // format error
6874 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6875 edgeColor.setRgbF( r, g, b );
6878 else if ( type == "node" ) {
6879 // node color is set by 3 values r:g:b, where
6880 // - r,g,b - is rgb color components
6881 if ( i+1 >= colors.count() ) break; // format error
6882 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6883 if ( i+2 >= colors.count() ) break; // format error
6884 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6885 if ( i+3 >= colors.count() ) break; // format error
6886 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6887 nodeColor.setRgbF( r, g, b );
6890 else if ( type == "elem0d" ) {
6891 // 0d element color is set by 3 values r:g:b, where
6892 // - r,g,b - is rgb color components
6893 if ( i+1 >= colors.count() ) break; // format error
6894 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6895 if ( i+2 >= colors.count() ) break; // format error
6896 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6897 if ( i+3 >= colors.count() ) break; // format error
6898 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6899 elem0dColor.setRgbF( r, g, b );
6902 else if ( type == "ball" ) {
6903 // ball color is set by 3 values r:g:b, where
6904 // - r,g,b - is rgb color components
6905 if ( i+1 >= colors.count() ) break; // format error
6906 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6907 if ( i+2 >= colors.count() ) break; // format error
6908 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6909 if ( i+3 >= colors.count() ) break; // format error
6910 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6911 ballColor.setRgbF( r, g, b );
6914 else if ( type == "outline" ) {
6915 // outline color is set by 3 values r:g:b, where
6916 // - r,g,b - is rgb color components
6917 if ( i+1 >= colors.count() ) break; // format error
6918 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6919 if ( i+2 >= colors.count() ) break; // format error
6920 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6921 if ( i+3 >= colors.count() ) break; // format error
6922 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6923 outlineColor.setRgbF( r, g, b );
6926 else if ( type == "orientation" ) {
6927 // orientation color is set by 3 values r:g:b, where
6928 // - r,g,b - is rgb color components
6929 if ( i+1 >= colors.count() ) break; // format error
6930 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6931 if ( i+2 >= colors.count() ) break; // format error
6932 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6933 if ( i+3 >= colors.count() ) break; // format error
6934 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6935 orientationColor.setRgbF( r, g, b );
6940 if ( nodeColor.isValid() )
6941 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6943 if ( edgeColor.isValid() )
6944 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6946 if ( faceColor.isValid() )
6947 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6949 if ( volumeColor.isValid() )
6950 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6951 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6952 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6954 if ( elem0dColor.isValid() )
6955 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6957 if ( ballColor.isValid() )
6958 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6960 if ( outlineColor.isValid() )
6961 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6962 // orientation color
6963 if ( orientationColor.isValid() )
6964 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6967 else if (paramNameStr == "Sizes") {
6968 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6971 int outlineWidth = -1;
6972 int elem0dSize = -1;
6973 //int ballSize = -1;
6974 double ballDiameter = -1.0;
6975 double ballScale = -1.0;
6976 double shrinkSize = -1;
6977 double orientationSize = -1;
6978 bool orientation3d = false;
6979 for ( int i = 0; i < sizes.count(); i++ ) {
6980 QString type = sizes[i];
6981 if ( type == "line" ) {
6982 // line (wireframe) width is given as single integer value
6983 if ( i+1 >= sizes.count() ) break; // format error
6984 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6988 if ( type == "outline" ) {
6989 // outline width is given as single integer value
6990 if ( i+1 >= sizes.count() ) break; // format error
6991 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6995 else if ( type == "elem0d" ) {
6996 // 0d element size is given as single integer value
6997 if ( i+1 >= sizes.count() ) break; // format error
6998 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7002 else if ( type == "ball" ) {
7003 // balls are specified by two values: size:scale, where
7004 // - size - is a integer value specifying size
7005 // - scale - is a double value specifying scale factor
7006 if ( i+1 >= sizes.count() ) break; // format error
7007 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7008 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7009 if ( i+2 >= sizes.count() ) break; // format error
7010 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
7016 else if ( type == "shrink" ) {
7017 // shrink factor is given as single floating point value
7018 if ( i+1 >= sizes.count() ) break; // format error
7019 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7023 else if ( type == "orientation" ) {
7024 // orientation vectors are specified by two values size:3d, where
7025 // - size - is a floating point value specifying scale factor
7026 // - 3d - is a boolean
7027 if ( i+1 >= sizes.count() ) break; // format error
7028 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7029 if ( i+2 >= sizes.count() ) break; // format error
7030 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7031 orientationSize = v1;
7032 orientation3d = (bool)v2;
7036 // line (wireframe) width
7037 if ( lineWidth > 0 )
7038 aSmeshActor->SetLineWidth( lineWidth );
7040 if ( outlineWidth > 0 )
7041 aSmeshActor->SetOutlineWidth( outlineWidth );
7042 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7043 aSmeshActor->SetOutlineWidth( lineWidth );
7045 if ( elem0dSize > 0 )
7046 aSmeshActor->Set0DSize( elem0dSize );
7048 /*if ( ballSize > 0 )
7049 aSmeshActor->SetBallSize( ballSize );*/
7051 if ( ballDiameter > 0 )
7052 aSmeshActor->SetBallSize( ballDiameter );
7054 if ( ballScale > 0.0 )
7055 aSmeshActor->SetBallScale( ballScale );
7057 if ( shrinkSize > 0 )
7058 aSmeshActor->SetShrinkFactor( shrinkSize );
7059 // orientation vectors
7060 if ( orientationSize > 0 ) {
7061 aSmeshActor->SetFacesOrientationScale( orientationSize );
7062 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7066 else if (paramNameStr == "PointMarker") {
7067 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7068 if( data.count() >= 2 ) {
7070 int aParam1 = data[1].toInt( &ok );
7072 if( data[0] == "std" && data.count() == 3 ) {
7073 int aParam2 = data[2].toInt( &ok );
7074 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7076 else if( data[0] == "custom" ) {
7077 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7078 if( markerIt != myMarkerMap.end() ) {
7079 VTK::MarkerData aMarkerData = markerIt->second;
7080 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7087 else if (paramNameStr == "Opacity") {
7088 aSmeshActor->SetOpacity(val.toFloat());
7091 else if (paramNameStr.startsWith("ClippingPlane")) {
7092 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7093 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7094 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7095 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7096 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7097 // new format - val looks like "Off" or "0" (plane id)
7098 // (note: in new format "Off" value is used only for consistency,
7099 // so it is processed together with values in old format)
7100 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7101 if( anIsOldFormat ) {
7102 if (paramNameStr == "ClippingPlane1" || val == "Off")
7103 aSmeshActor->RemoveAllClippingPlanes();
7105 QList<SUIT_ViewManager*> lst;
7106 getApp()->viewManagers(viewerTypStr, lst);
7107 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7108 if (viewIndex >= 0 && viewIndex < lst.count()) {
7109 SUIT_ViewManager* vman = lst.at(viewIndex);
7110 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7112 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7114 SMESH::TActorList anActorList;
7115 anActorList.push_back( aSmeshActor );
7116 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7117 aPlane->myViewWindow = vtkView;
7118 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7119 aPlane->PlaneMode = aMode;
7120 bool isOpenGLClipping = ( bool )vals[1].toInt();
7121 aPlane->IsOpenGLClipping = isOpenGLClipping;
7122 if ( aMode == SMESH::Absolute ) {
7123 aPlane->myAbsoluteOrientation = vals[2].toInt();
7124 aPlane->X = vals[3].toFloat();
7125 aPlane->Y = vals[4].toFloat();
7126 aPlane->Z = vals[5].toFloat();
7127 aPlane->Dx = vals[6].toFloat();
7128 aPlane->Dy = vals[7].toFloat();
7129 aPlane->Dz = vals[8].toFloat();
7131 else if ( aMode == SMESH::Relative ) {
7132 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7133 aPlane->myDistance = vals[3].toFloat();
7134 aPlane->myAngle[0] = vals[4].toFloat();
7135 aPlane->myAngle[1] = vals[5].toFloat();
7139 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7140 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7141 aClippingPlaneInfo.Plane = aPlane;
7142 aClippingPlaneInfo.ActorList = anActorList;
7143 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7151 int aPlaneId = val.toInt( &ok );
7152 if( ok && aPlaneId >= 0 ) {
7153 bool anIsDefinedPlane = false;
7154 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7155 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7156 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7157 TPlaneInfo& aPlaneInfo = *anIter;
7158 if( aPlaneInfo.PlaneId == aPlaneId ) {
7159 aPlaneInfo.ActorList.push_back( aSmeshActor );
7160 anIsDefinedPlane = true;
7164 if( !anIsDefinedPlane ) {
7165 TPlaneInfo aPlaneInfo;
7166 aPlaneInfo.PlaneId = aPlaneId;
7167 aPlaneInfo.ActorList.push_back( aSmeshActor );
7168 aPlaneInfo.ViewManager = vman;
7170 // to make the list sorted by plane id
7171 anIter = aPlaneInfoList.begin();
7172 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7173 const TPlaneInfo& aPlaneInfoRef = *anIter;
7174 if( aPlaneInfoRef.PlaneId > aPlaneId )
7177 aPlaneInfoList.insert( anIter, aPlaneInfo );
7182 } // if (aSmeshActor)
7183 } // other parameters than Visibility
7185 } // for names/parameters iterator
7186 } // for entries iterator
7188 // take into account planes with empty list of actors referred to them
7189 QList<SUIT_ViewManager*> aVMList;
7190 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7192 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7193 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7194 int aViewId = aPlaneDataIter->first;
7195 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7196 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7198 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7200 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7201 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7202 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7203 const TPlaneData& aPlaneData = *anIter2;
7204 int aPlaneId = aPlaneData.Id;
7206 bool anIsFound = false;
7207 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7208 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7209 const TPlaneInfo& aPlaneInfo = *anIter3;
7210 if( aPlaneInfo.PlaneId == aPlaneId ) {
7217 TPlaneInfo aPlaneInfo; // ActorList field is empty
7218 aPlaneInfo.PlaneId = aPlaneId;
7219 aPlaneInfo.ViewManager = aViewManager;
7221 // to make the list sorted by plane id
7222 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7223 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7224 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7225 if( aPlaneInfoRef.PlaneId > aPlaneId )
7228 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7234 // add clipping planes to actors according to the restored parameters
7235 // and update the clipping plane map
7236 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7237 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7238 int aViewId = anIter1->first;
7239 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7241 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7242 if( anIter2 == aPlaneDataMap.end() )
7244 const TPlaneDataList& aPlaneDataList = anIter2->second;
7246 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7247 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7248 const TPlaneInfo& aPlaneInfo = *anIter3;
7249 int aPlaneId = aPlaneInfo.PlaneId;
7250 const TActorList& anActorList = aPlaneInfo.ActorList;
7251 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7255 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7259 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7261 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7262 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7263 const TPlaneData& aPlaneData = *anIter4;
7264 if( aPlaneData.Id == aPlaneId ) {
7265 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7266 aPlane->myViewWindow = aViewWindow;
7267 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7268 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7269 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7270 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7271 aPlane->X = aPlaneData.X;
7272 aPlane->Y = aPlaneData.Y;
7273 aPlane->Z = aPlaneData.Z;
7274 aPlane->Dx = aPlaneData.Dx;
7275 aPlane->Dy = aPlaneData.Dy;
7276 aPlane->Dz = aPlaneData.Dz;
7278 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7279 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7280 aPlane->myDistance = aPlaneData.Distance;
7281 aPlane->myAngle[0] = aPlaneData.Angle[0];
7282 aPlane->myAngle[1] = aPlaneData.Angle[1];
7285 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7286 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7287 aClippingPlaneInfo.Plane = aPlane;
7288 aClippingPlaneInfo.ActorList = anActorList;
7289 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7300 // update all VTK views
7301 QList<SUIT_ViewManager*> lst;
7302 getApp()->viewManagers(lst);
7303 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7304 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7305 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7306 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7307 // set OpenGL clipping planes
7308 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7309 vtkActorCollection* anAllActors = aCopy.GetActors();
7310 anAllActors->InitTraversal();
7311 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7312 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7313 anActor->SetOpenGLClippingPlane();
7315 vtkView->getRenderer()->ResetCameraClippingRange();
7322 \brief Adds preferences for dfont of VTK viewer
7324 \param pIf group identifier
7325 \param param parameter
7326 \return identifier of preferences
7328 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7330 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7332 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7335 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7336 fam.append( tr( "SMESH_FONT_COURIER" ) );
7337 fam.append( tr( "SMESH_FONT_TIMES" ) );
7339 setPreferenceProperty( tfont, "fonts", fam );
7341 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7342 if ( needSize ) f = f | QtxFontEdit::Size;
7343 setPreferenceProperty( tfont, "features", f );
7349 \brief Actions after hypothesis edition
7350 Updates object browser after hypothesis edition
7352 void SMESHGUI::onHypothesisEdit( int result )
7355 SMESHGUI::Modified();
7356 updateObjBrowser( true );
7360 \brief Actions after choosing menu of control modes
7361 Updates control mode actions according to current selection
7363 void SMESHGUI::onUpdateControlActions()
7365 SALOME_ListIO selected;
7366 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7367 aSel->selectedObjects( selected );
7369 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7370 if ( selected.Extent() ) {
7371 if ( selected.First()->hasEntry() ) {
7372 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7373 aControl = anActor->GetControlMode();
7374 SALOME_ListIteratorOfListIO it(selected);
7375 for ( it.Next(); it.More(); it.Next() ) {
7376 Handle(SALOME_InteractiveObject) anIO = it.Value();
7377 if ( anIO->hasEntry() ) {
7378 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7379 if ( aControl != anActor->GetControlMode() ) {
7380 aControl = SMESH_Actor::eNone;
7390 int anAction = ActionToControl( aControl, true );
7392 action( anAction )->setChecked( true );
7394 QMenu* send = (QMenu*)sender();
7395 QList<QAction*> actions = send->actions();
7396 for ( int i = 0; i < actions.size(); i++ )
7397 actions[i]->setChecked( false );
7403 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7404 \param pview view being closed
7406 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7407 #ifndef DISABLE_PLOT2DVIEWER
7408 //Crear all Plot2d Viewers if need.
7409 SMESH::ClearPlot2Viewers(pview);
7411 EmitSignalCloseView();
7414 void SMESHGUI::message( const QString& msg )
7417 QStringList data = msg.split("/");
7418 if ( data.count() > 0 ) {
7419 if ( data.first() == "mesh_loading" ) {
7421 QString entry = data.count() > 1 ? data[1] : QString();
7422 if ( entry.isEmpty() )
7425 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7427 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7430 name = SMESH::fromUtf8(obj->GetName());
7431 if ( name.isEmpty() )
7434 if ( data.last() == "stop" )
7435 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7437 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7438 QApplication::processEvents();
7444 \brief Connects or disconnects signals about activating and cloning view on the module slots
7445 \param pview view which is connected/disconnected
7447 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7451 SUIT_ViewManager* viewMgr = pview->getViewManager();
7453 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7454 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7456 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7457 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7462 \brief Return \c true if object can be renamed
7464 bool SMESHGUI::renameAllowed( const QString& entry) const {
7465 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7469 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7473 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7478 if(appStudy->isComponent(entry) || obj->isReference())
7481 // check type to prevent renaming of inappropriate objects
7482 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7483 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7484 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7485 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7486 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7487 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7494 Rename object by entry.
7495 \param entry entry of the object
7496 \param name new name of the object
7497 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7499 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7501 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7505 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7510 _PTR(Study) aStudy = appStudy->studyDS();
7515 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7517 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7522 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7523 _PTR(GenericAttribute) anAttr;
7524 _PTR(AttributeName) aName;
7526 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7528 // check type to prevent renaming of inappropriate objects
7529 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7530 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7531 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7532 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7533 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7534 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7535 if ( !name.isEmpty() ) {
7536 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7538 // update name of group object and its actor
7539 Handle(SALOME_InteractiveObject) IObject =
7540 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7542 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7543 if( !aGroupObject->_is_nil() ) {
7544 aGroupObject->SetName( qUtf8Printable(name) );
7545 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7546 anActor->setName( qUtf8Printable(name) );
7556 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7558 static QList<QColor> colors;
7560 if ( colors.isEmpty() ) {
7562 for (int s = 0; s < 2 ; s++)
7564 for (int v = 100; v >= 40; v = v - 20)
7566 for (int h = 0; h < 359 ; h = h + 60)
7568 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7573 static int currentColor = randomize( colors.size() );
7575 SALOMEDS::Color color;
7576 color.R = (double)colors[currentColor].red() / 255.0;
7577 color.G = (double)colors[currentColor].green() / 255.0;
7578 color.B = (double)colors[currentColor].blue() / 255.0;
7580 currentColor = (currentColor+1) % colors.count();