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::long_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){
999 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1000 QObject::tr("SMESH_WRN_WARNING"),
1001 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1007 inline void InverseEntityMode(unsigned int& theOutputMode,
1008 unsigned int theMode)
1010 bool anIsNotPresent = ~theOutputMode & theMode;
1012 theOutputMode |= theMode;
1014 theOutputMode &= ~theMode;
1017 void SetDisplayEntity(int theCommandID)
1019 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1020 SALOME_ListIO selected;
1022 aSel->selectedObjects( selected );
1024 if ( selected.Extent() >= 1 ) {
1025 SUIT_OverrideCursor wc;
1026 SALOME_ListIteratorOfListIO It( selected );
1027 for( ; It.More(); It.Next()){
1028 Handle(SALOME_InteractiveObject) IObject = It.Value();
1029 if(IObject->hasEntry()){
1030 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1031 unsigned int aMode = anActor->GetEntityMode();
1032 switch(theCommandID){
1033 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1034 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1035 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1036 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1037 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1038 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1041 anActor->SetEntityMode(aMode);
1050 SalomeApp_Application* app =
1051 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1055 LightApp_SelectionMgr* aSel = app->selectionMgr();
1056 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1057 if ( !aSel || !appStudy )
1060 SALOME_ListIO selected;
1061 aSel->selectedObjects( selected );
1062 if ( selected.IsEmpty() )
1065 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1067 _PTR(Study) aStudy = appStudy->studyDS();
1068 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1069 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1070 if ( aMainObject->_is_nil() )
1073 SUIT_OverrideCursor wc;
1075 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1077 QList<SALOMEDS::Color> aReservedColors;
1079 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1080 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1082 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1084 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1085 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1086 #else // old algorithm for auto-colors
1087 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1088 aReservedColors.append( aColor );
1089 #endif // SIMPLE_AUTOCOLOR
1090 aGroupObject->SetColor( aColor );
1092 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1093 if ( aGroupSObject ) {
1096 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1097 switch ( aGroupObject->GetType ()) {
1099 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1101 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1103 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1105 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1107 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1108 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1111 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1112 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1118 SMESH::RepaintCurrentView();
1121 void OverallMeshQuality()
1123 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1124 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1125 SALOME_ListIO selected;
1127 aSel->selectedObjects( selected );
1129 if ( selected.IsEmpty() ) return;
1130 SALOME_ListIteratorOfListIO It( selected );
1131 for ( ; It.More(); It.Next() ) {
1132 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1133 ctrlDlg->showInfo( It.Value() );
1138 QString functorToString( SMESH::Controls::FunctorPtr f )
1140 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1141 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1142 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1143 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1144 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1145 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1146 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1147 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1148 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1149 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1150 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1151 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1152 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1153 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1154 type = QObject::tr( "WARP_ELEMENTS" );
1155 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1156 type = QObject::tr( "TAPER_ELEMENTS" );
1157 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1158 type = QObject::tr( "SKEW_ELEMENTS" );
1159 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1160 type = QObject::tr( "AREA_ELEMENTS" );
1161 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1162 type = QObject::tr( "LENGTH_EDGES" );
1163 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1164 type = QObject::tr( "LENGTH2D_EDGES" );
1165 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1166 type = QObject::tr( "DEFLECTION2D_FACES" );
1167 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1168 type = QObject::tr( "MULTI_BORDERS" );
1169 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1170 type = QObject::tr( "MULTI2D_BORDERS" );
1171 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1172 type = QObject::tr( "FREE_NODES" );
1173 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1174 type = QObject::tr( "FREE_EDGES" );
1175 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1176 type = QObject::tr( "FREE_BORDERS" );
1177 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1178 type = QObject::tr( "FREE_FACES" );
1179 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1180 type = QObject::tr( "BARE_BORDER_VOLUME" );
1181 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1182 type = QObject::tr( "BARE_BORDER_FACE" );
1183 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1184 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1185 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1186 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1187 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1188 type = QObject::tr( "EQUAL_NODE" );
1189 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1190 type = QObject::tr( "EQUAL_EDGE" );
1191 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1192 type = QObject::tr( "EQUAL_FACE" );
1193 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1194 type = QObject::tr( "EQUAL_VOLUME" );
1195 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1196 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1200 void SaveDistribution()
1202 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1203 SALOME_ListIO selected;
1205 aSel->selectedObjects( selected );
1207 if ( selected.Extent() == 1 ) {
1208 Handle(SALOME_InteractiveObject) anIO = selected.First();
1209 if ( anIO->hasEntry() ) {
1210 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1212 anActor->GetScalarBarActor() &&
1213 anActor->GetControlMode() != SMESH_Actor::eNone )
1215 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1216 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1217 if ( aScalarBarActor && aFunctor ) {
1218 SMESH::Controls::NumericalFunctor* aNumFun =
1219 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1221 std::vector<int> elements;
1222 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1223 if ( mesh->_is_nil() ) {
1224 SMESH::SMESH_IDSource_var idSource =
1225 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1226 if ( !idSource->_is_nil() )
1228 SMESH::long_array_var ids = idSource->GetIDs();
1229 elements.resize( ids->length() );
1230 for ( unsigned i = 0; i < elements.size(); ++i )
1231 elements[i] = ids[i];
1234 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1235 vtkLookupTable* lookupTable =
1236 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1237 double * minmax = lookupTable->GetRange();
1238 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1239 std::vector<int> nbEvents;
1240 std::vector<double> funValues;
1241 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1242 elements, minmax, isLogarithmic );
1243 QString anInitialPath = "";
1244 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1245 anInitialPath = QDir::currentPath();
1246 QString aMeshName = anIO->getName();
1248 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1249 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1250 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1251 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1252 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1255 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1257 if ( !aFilename.isEmpty() ) {
1258 QFile f( aFilename );
1259 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1260 QTextStream out( &f );
1261 out << "# Mesh: " << aMeshName << endl;
1262 out << "# Control: " << functorToString( aFunctor ) << endl;
1264 out.setFieldWidth( 10 );
1265 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1266 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1277 void ShowElement( int theCommandID )
1279 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1280 SALOME_ListIO selected;
1282 aSel->selectedObjects( selected );
1284 if ( selected.Extent() == 1 ) {
1285 Handle(SALOME_InteractiveObject) anIO = selected.First();
1286 if ( anIO->hasEntry() ) {
1287 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1289 anActor->GetScalarBarActor() &&
1290 anActor->GetControlMode() != SMESH_Actor::eNone )
1292 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1293 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1294 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1296 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1297 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1304 #ifndef DISABLE_PLOT2DVIEWER
1305 void PlotDistribution()
1307 SalomeApp_Application* app =
1308 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1312 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1313 SALOME_ListIO selected;
1315 aSel->selectedObjects( selected );
1317 if ( selected.Extent() == 1 ) {
1318 Handle(SALOME_InteractiveObject) anIO = selected.First();
1319 if ( anIO->hasEntry() ) {
1320 //Find Actor by entry before getting Plot2d viewer,
1321 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1322 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1324 SUIT_ViewManager* aViewManager =
1325 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1329 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1333 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1337 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1339 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1340 QString functorName = functorToString( anActor->GetFunctor());
1341 QString aHistogramName("%1 : %2");
1342 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1343 aHistogram->setName(aHistogramName);
1344 aHistogram->setHorTitle(functorName);
1345 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1346 aPlot->displayObject(aHistogram, true);
1351 #endif //DISABLE_PLOT2DVIEWER
1353 void DisableAutoColor()
1355 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1356 SALOME_ListIO selected;
1358 aSel->selectedObjects( selected );
1360 if ( selected.Extent() ) {
1361 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1362 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1363 if ( !aMesh->_is_nil() ) {
1364 aMesh->SetAutoColor( false );
1371 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1372 SALOME_ListIO selected;
1374 aSel->selectedObjects( selected );
1375 if ( selected.Extent() )
1377 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1378 _PTR(Study) aStudy = SMESH::getStudy();
1379 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1381 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1382 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1389 // Break link with Shaper model
1390 void breakShaperLink()
1392 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1393 SALOME_ListIO selected;
1395 aSel->selectedObjects(selected);
1396 if (selected.Extent()) {
1397 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1398 _PTR(Study) aStudy = SMESH::getStudy();
1399 std::string aEntry = anIObject->getEntry();
1400 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1402 std::string aName = aSObj->GetName();
1403 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1404 QObject::tr("SMESH_WRN_WARNING"),
1405 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1406 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1407 if (aRes == SUIT_MessageBox::Yes) {
1408 SUIT_DataOwnerPtrList aList;
1409 aSel->selected(aList, "ObjectBrowser", true);
1410 SUIT_DataOwner* aOwn = aList.first();
1411 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1412 QString aREntry = sowner->entry();
1414 static GEOM::GEOM_Gen_var geomGen;
1415 if (CORBA::is_nil(geomGen)) {
1416 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1417 (SUIT_Session::session()->activeApplication());
1419 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1420 Engines::EngineComponent_var comp =
1421 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1422 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1425 if (!CORBA::is_nil(geomGen))
1427 geomGen->BreakLink(aREntry.toStdString().c_str());
1428 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1430 // remove actors whose objects are removed by BreakLink()
1431 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1432 SUIT_ViewWindow* wnd;
1433 foreach(wnd, wndList)
1434 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1442 //================================================================================
1444 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1445 * which means that the mesh can't be modified. It should be either re-computed
1446 * or breakShaperLink()'ed. Warn the user about it.
1448 //================================================================================
1450 bool warnOnGeomModif()
1452 SALOME_ListIO selected;
1453 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1454 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1456 SALOME_ListIteratorOfListIO It( selected );
1457 for ( ; It.More(); It.Next() )
1459 Handle(SALOME_InteractiveObject) io = It.Value();
1460 if ( !io->hasEntry() ) continue;
1461 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1462 SMESH::SMESH_Mesh_var mesh;
1463 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1465 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1466 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1467 if ( isrc->_is_nil() )
1468 so = so->GetFather();
1470 mesh = isrc->GetMesh();
1472 if ( mesh->_is_nil() ) continue;
1473 so = SMESH::FindSObject( mesh );
1474 if ( !so ) continue;
1475 _PTR(GenericAttribute) attr;
1476 so->FindAttribute( attr, "AttributePixMap" );
1477 _PTR(AttributePixMap) pixmap = attr;
1478 if ( !pixmap ) continue;
1480 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1482 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1483 QObject::tr("SMESH_WRN_WARNING"),
1484 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1491 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1493 SALOME_ListIO selected;
1494 SalomeApp_Application* app =
1495 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1499 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1500 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1501 if ( !aSel || !appStudy )
1504 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1505 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1506 aModule->EmitSignalDeactivateDialog();
1507 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1508 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1513 aSel->selectedObjects( selected );
1515 if ( selected.Extent() >= 1 )
1517 switch ( theCommandID ) {
1518 case SMESHOp::OpTransparency:
1520 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1521 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1524 case SMESHOp::OpProperties:
1527 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1528 QColor orientationColor, outlineColor, volumeColor;
1529 int deltaF = 0, deltaV = 0;
1532 double ballScale = 1.0;
1534 int outlineWidth = 1;
1535 double shrinkCoef = 0.0;
1536 double orientationScale = 0.0;
1537 bool orientation3d = false;
1538 VTK::MarkerType markerType = VTK::MT_NONE;
1539 VTK::MarkerScale markerScale = VTK::MS_NONE;
1541 bool hasNodes = false;
1542 int presentEntities = 0;
1543 bool firstTime = true;
1545 SALOME_ListIteratorOfListIO It( selected );
1546 for ( ; It.More(); It.Next() ) {
1547 Handle(SALOME_InteractiveObject) IObject = It.Value();
1548 if ( !IObject->hasEntry() ) continue;
1549 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1550 if ( !anActor || !anActor->GetObject() ) continue;
1553 // nodes: color, marker
1554 anActor->GetNodeColor( color[0], color[1], color[2] );
1555 nodeColor.setRgbF( color[0], color[1], color[2] );
1556 markerType = anActor->GetMarkerType();
1557 markerScale = anActor->GetMarkerScale();
1558 markerId = anActor->GetMarkerTexture();
1559 // edges: color, width
1560 anActor->GetEdgeColor( color[0], color[1], color[2] );
1561 edgeColor.setRgbF( color[0], color[1], color[2] );
1562 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1563 // faces: front color, back color (delta)
1564 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1565 faceColor.setRgbF( color[0], color[1], color[2] );
1566 // faces: front color, back color (delta)
1567 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1568 volumeColor.setRgbF( color[0], color[1], color[2] );
1569 // 0d elements: color, size
1570 anActor->Get0DColor( color[0], color[1], color[2] );
1571 elem0dColor.setRgbF( color[0], color[1], color[2] );
1572 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1573 // balls: color, size
1574 anActor->GetBallColor( color[0], color[1], color[2] );
1575 ballColor.setRgbF( color[0], color[1], color[2] );
1576 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1577 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1579 anActor->GetOutlineColor( color[0], color[1], color[2] );
1580 outlineColor.setRgbF( color[0], color[1], color[2] );
1581 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1582 // orientation vectors: color, scale, 3d flag
1583 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1584 orientationColor.setRgbF( color[0], color[1], color[2] );
1585 orientationScale = anActor->GetFacesOrientationScale();
1586 orientation3d = anActor->GetFacesOrientation3DVectors();
1588 shrinkCoef = anActor->GetShrinkFactor();
1591 firstTime = false; // we only take properties from first object (for performance reasons)
1594 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1595 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1596 presentEntities = presentEntities | SMESH_Actor::eEdges;
1597 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1598 presentEntities = presentEntities | SMESH_Actor::eFaces;
1599 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1600 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1601 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1602 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1603 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1604 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1606 // as we know that all types of elements are present, we can exit the loop
1607 if ( presentEntities == SMESH_Actor::eAllEntity )
1611 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1612 // nodes: color, marker
1613 dlg.setNodeColor( nodeColor );
1614 if( markerType != VTK::MT_USER )
1615 dlg.setNodeMarker( markerType, markerScale );
1617 dlg.setNodeCustomMarker( markerId );
1618 // edges: color, line width
1619 dlg.setEdgeColor( edgeColor );
1620 dlg.setEdgeWidth( edgeWidth );
1621 // faces: front color, back color
1622 dlg.setFaceColor( faceColor, deltaF );
1623 // volumes: normal color, reversed color
1624 dlg.setVolumeColor( volumeColor, deltaV );
1625 // outlines: color, line width
1626 dlg.setOutlineColor( outlineColor );
1627 dlg.setOutlineWidth( outlineWidth );
1628 // 0d elements: color, size
1629 dlg.setElem0dColor( elem0dColor );
1630 dlg.setElem0dSize( elem0dSize );
1631 // balls: color, size
1632 dlg.setBallColor( ballColor );
1633 //dlg.setBallSize( ballSize );
1634 dlg.setBallScale( ballScale );
1635 // orientation: color, scale, 3d flag
1636 dlg.setOrientationColor( orientationColor );
1637 dlg.setOrientationSize( int( orientationScale * 100. ) );
1638 dlg.setOrientation3d( orientation3d );
1639 // shrink: scale factor
1640 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1641 // hide unused controls
1642 dlg.showControls( presentEntities, hasNodes );
1645 nodeColor = dlg.nodeColor();
1646 markerType = dlg.nodeMarkerType();
1647 markerScale = dlg.nodeMarkerScale();
1648 markerId = dlg.nodeMarkerId();
1649 edgeColor = dlg.edgeColor();
1650 edgeWidth = dlg.edgeWidth();
1651 faceColor = dlg.faceColor();
1652 deltaF = dlg.faceColorDelta();
1653 volumeColor = dlg.volumeColor();
1654 deltaV = dlg.volumeColorDelta();
1655 outlineColor = dlg.outlineColor();
1656 outlineWidth = dlg.outlineWidth();
1657 elem0dColor = dlg.elem0dColor();
1658 elem0dSize = dlg.elem0dSize();
1659 ballColor = dlg.ballColor();
1660 // ballSize = dlg.ballSize();
1661 ballScale = dlg.ballScale();
1662 orientationColor = dlg.orientationColor();
1663 orientationScale = dlg.orientationSize() / 100.;
1664 orientation3d = dlg.orientation3d();
1665 shrinkCoef = dlg.shrinkCoef() / 100.;
1667 // store point markers that might be changed by the user
1668 theMarkerMap = dlg.customMarkers();
1670 // set properties from dialog box to the presentations
1671 SALOME_ListIteratorOfListIO It( selected );
1672 for ( ; It.More(); It.Next() ) {
1673 Handle(SALOME_InteractiveObject) IObject = It.Value();
1674 if ( !IObject->hasEntry() ) continue;
1675 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1676 if ( !anActor ) continue;
1678 // nodes: color, marker
1679 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1680 if ( markerType != VTK::MT_USER ) {
1681 anActor->SetMarkerStd( markerType, markerScale );
1684 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1685 if ( iter != theMarkerMap.end() )
1686 anActor->SetMarkerTexture( markerId, iter->second.second );
1688 // volumes: normal color, reversed color (delta)
1689 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1690 // faces: front color, back color (delta)
1691 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1692 // edges: color, width
1693 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1694 anActor->SetLineWidth( edgeWidth );
1696 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1697 anActor->SetOutlineWidth( outlineWidth );
1698 // 0D elements: color, size
1699 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1700 anActor->Set0DSize( elem0dSize );
1701 // balls: color, size
1702 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1703 // anActor->SetBallSize( ballSize );
1704 anActor->SetBallScale( ballScale );
1705 // orientation: color, scale, 3d flag
1706 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1707 anActor->SetFacesOrientationScale( orientationScale );
1708 anActor->SetFacesOrientation3DVectors( orientation3d );
1710 anActor->SetShrinkFactor( shrinkCoef );
1712 // for groups, set also proper color
1713 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1714 if ( !aGroupObject->_is_nil() ) {
1715 SMESH::ElementType anElementType = aGroupObject->GetType();
1717 switch( anElementType ) {
1719 aColor = nodeColor; break;
1721 aColor = edgeColor; break;
1723 aColor = faceColor; break;
1725 aColor = volumeColor; break;
1727 aColor = elem0dColor; break;
1729 aColor = ballColor; break;
1733 if ( aColor.isValid() ) {
1734 SALOMEDS::Color aGroupColor;
1735 aGroupColor.R = aColor.redF();
1736 aGroupColor.G = aColor.greenF();
1737 aGroupColor.B = aColor.blueF();
1738 aGroupObject->SetColor( aGroupColor );
1740 } // if ( !aGroupObject->_is_nil() )
1741 } // for ( ; It.More(); It.Next() )
1742 SMESH::RepaintCurrentView();
1743 } // if ( dlg.exec() )
1745 } // case SMESHOp::OpProperties:
1746 } // switch(theCommandID)
1747 SUIT_OverrideCursor wc;
1748 SALOME_ListIteratorOfListIO It( selected );
1749 for( ; It.More(); It.Next()){
1750 Handle(SALOME_InteractiveObject) IObject = It.Value();
1751 if(IObject->hasEntry()){
1752 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1753 switch(theCommandID){
1754 case SMESHOp::OpDMWireframe:
1755 anActor->SetRepresentation(SMESH_Actor::eEdge);
1757 case SMESHOp::OpDMShading:
1758 anActor->SetRepresentation(SMESH_Actor::eSurface);
1760 case SMESHOp::OpDMShrink:
1761 if(anActor->IsShrunk())
1762 anActor->UnShrink();
1764 anActor->SetShrink();
1766 case SMESHOp::OpDMNodes:
1767 anActor->SetRepresentation(SMESH_Actor::ePoint);
1769 case SMESHOp::OpRepresentationLines:
1770 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1771 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1773 case SMESHOp::OpRepresentationArcs:
1774 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1775 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1781 SMESH::RepaintCurrentView();
1785 int ActionToControl( int theID, bool theReversed )
1787 NCollection_DoubleMap<int,int> ActionControl;
1788 ActionControl.Bind( 0, SMESH_Actor::eNone );
1789 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1790 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1791 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1792 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1793 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1794 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1795 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1796 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1797 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1798 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1799 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1800 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1801 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1802 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1803 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1804 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1805 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1806 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1807 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1808 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1809 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1810 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1811 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1812 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1813 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1814 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1815 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1816 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1819 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1820 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1823 void Control( int theCommandID )
1825 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1826 _PTR(Study) aStudy = SMESH::getStudy();
1828 SALOME_ListIO selected;
1829 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1830 aSel->selectedObjects( selected );
1832 if ( !selected.IsEmpty() ) {
1833 SALOME_ListIteratorOfListIO It(selected);
1834 for ( ; It.More(); It.Next())
1836 Handle(SALOME_InteractiveObject) anIO = It.Value();
1837 if ( !anIO.IsNull() ) {
1838 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1840 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1841 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1842 if ( !anIDSrc->_is_nil() ) {
1843 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1844 if (( !anActor && selected.Extent() == 1 ) &&
1845 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1847 anActor->SetControlMode( aControl );
1848 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1849 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1853 if ( anActor->GetControlMode() != aControl )
1854 anActor->SetControlMode( aControl );
1855 QString functorName = functorToString( anActor->GetFunctor() );
1856 int anEntitiesCount = anActor->GetNumberControlEntities();
1857 if (anEntitiesCount >= 0)
1858 functorName = functorName + ": " + QString::number(anEntitiesCount);
1859 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1860 SMESH::RepaintCurrentView();
1861 #ifndef DISABLE_PLOT2DVIEWER
1862 if ( anActor->GetPlot2Histogram() ) {
1863 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1864 QString aHistogramName("%1 : %2");
1865 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1866 aHistogram->setName( aHistogramName );
1867 aHistogram->setHorTitle( functorName );
1868 SMESH::ProcessIn2DViewers( anActor );
1880 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1881 SMESH::MeshObjectType theType,
1882 const QString theInTypeName,
1883 QString & theOutTypeName)
1885 SMESH_TypeFilter aTypeFilter( theType );
1887 if ( !theIO.IsNull() )
1889 entry = theIO->getEntry();
1890 LightApp_DataOwner owner( entry );
1891 if ( aTypeFilter.isOk( &owner )) {
1892 theOutTypeName = theInTypeName;
1900 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1902 _PTR(Study) aStudy = SMESH::getStudy();
1903 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1905 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1906 CORBA::String_var anID = aSComp->GetID().c_str();
1907 if ( !strcmp(anID.in(),theIO->getEntry()) )
1913 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1914 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1915 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1916 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1917 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1925 // QString CheckHomogeneousSelection()
1927 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1928 // SALOME_ListIO selected;
1930 // aSel->selectedObjects( selected );
1932 // QString RefType = CheckTypeObject(selected.First());
1933 // SALOME_ListIteratorOfListIO It(selected);
1934 // for ( ; It.More(); It.Next())
1936 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1937 // QString Type = CheckTypeObject(IObject);
1938 // if ( Type.compare(RefType) != 0 )
1939 // return "Heterogeneous Selection";
1945 uint randomize( uint size )
1947 static bool initialized = false;
1948 if ( !initialized ) {
1949 qsrand( QDateTime::currentDateTime().toTime_t() );
1953 v = uint( (double)( v ) / RAND_MAX * size );
1954 v = qMax( uint(0), qMin ( v, size-1 ) );
1960 void SMESHGUI::OnEditDelete()
1962 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1963 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1964 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1966 _PTR(Study) aStudy = SMESH::getStudy();
1967 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1968 _PTR(GenericAttribute) anAttr;
1969 _PTR(AttributeIOR) anIOR;
1971 const int objectCountLimit = 30; // PAL23599
1972 int objectCount = 0;
1974 QString aParentComponent = QString::null;
1976 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1978 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1979 if ( anIO.IsNull() ) continue;
1981 QString father = "unknown", name;
1983 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1985 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1986 // check if object is reference
1987 _PTR(SObject) aRefSObj;
1988 if ( aSO->ReferencedObject( aRefSObj ) ) {
1989 name = QString::fromStdString ( aRefSObj->GetName() );
1990 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1993 name = anIO->getName();
1996 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1997 aNameList.append("\n - ");
1998 aNameList.append( name );
2001 if( aParentComponent.isNull() )
2002 aParentComponent = father;
2003 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2004 aParentComponent = "";
2006 if ( objectCount >= objectCountLimit )
2007 aNameList.append("\n - ...");
2009 if ( objectCount == 0 )
2010 return; // No Valid Objects Selected
2012 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2013 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2014 QObject::tr("ERR_ERROR"),
2015 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2018 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2019 if (SUIT_MessageBox::warning
2020 (SMESHGUI::desktop(),
2021 QObject::tr("SMESH_WRN_WARNING"),
2022 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2023 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2024 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2027 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2029 // Put one level of sub-objects of the selected SO's into a list
2030 // in order to get objects inside folders like "Assigned Algorithms"
2031 std::list< _PTR(SObject) > listSO;
2032 SALOME_ListIteratorOfListIO It(selected);
2033 for( ; It.More(); It.Next()) // loop on selected IO's
2035 Handle(SALOME_InteractiveObject) IObject = It.Value();
2036 if(IObject->hasEntry()) {
2037 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2039 // disable removal of "SMESH" component object
2040 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2042 if ( engineIOR() == anIOR->Value().c_str() )
2045 //Check the referenced object
2046 _PTR(SObject) aRefSObject;
2047 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2048 aSO = aRefSObject; // Delete main Object instead of reference
2050 listSO.push_back( aSO );
2052 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2053 for (it->InitEx(false); it->More(); it->Next())
2054 listSO.push_back( it->Value() );
2057 // Check if none of objects to delete is referred from outside
2058 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2059 std::vector< _PTR(SObject) > subSO;
2060 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2062 _PTR(SObject) SO = *ritSO;
2063 if ( !SO ) continue;
2065 int nbChildren = SO->GetLastChildTag();
2067 subSO.reserve( 1 + nbChildren );
2068 subSO.push_back( SO );
2069 if ( nbChildren > 0 )
2071 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2072 for ( it->InitEx( true ); it->More(); it->Next() )
2073 subSO.push_back( it->Value() );
2075 for ( size_t i = 0; i < subSO.size(); ++i )
2077 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2078 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2079 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2080 std::string type = aComponent->ComponentDataType();
2081 if ( type != "SMESH" )
2083 SUIT_MessageBox::warning( anApp->desktop(),
2084 QObject::tr("WRN_WARNING"),
2085 QObject::tr("DEP_OBJECT") );
2086 return; // outside SMESH, there is an object depending on a SMESH object
2092 // Treat SO's in the list starting from the back
2093 aStudyBuilder->NewCommand(); // There is a transaction
2094 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2096 _PTR(SObject) SO = *ritSO;
2097 if ( !SO ) continue;
2098 std::string anEntry = SO->GetID();
2100 /** Erase graphical object and remove all its data **/
2101 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2102 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2104 /** Remove an object from data structures **/
2105 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2106 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2107 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2108 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2109 aMesh->RemoveGroup( aGroup );
2111 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2112 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2113 aMesh->RemoveSubMesh( aSubMesh );
2116 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2117 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2118 QString objType = CheckTypeObject(IObject);
2119 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2120 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2121 aStudyBuilder->RemoveObjectWithChildren( SO );
2123 else {// default action: remove SObject from the study
2124 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2125 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2127 aStudyBuilder->RemoveObjectWithChildren( SO );
2131 } /* listSO back loop */
2133 aStudyBuilder->CommitCommand();
2135 /* Clear any previous selection */
2137 aSel->setSelectedObjects( l1 );
2139 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2143 SMESHGUI_EXPORT CAM_Module* createModule()
2145 return new SMESHGUI();
2148 SMESHGUI_EXPORT char* getModuleVersion() {
2149 return (char*)SMESH_VERSION_STR;
2153 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2155 //=============================================================================
2159 //=============================================================================
2160 SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
2162 if ( CORBA::is_nil( myComponentSMESH ) )
2164 CORBA::Boolean anIsEmbeddedMode;
2165 SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
2166 if( dynamic_cast<SALOME_NamingService *>(ns) )
2167 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2170 Engines::EngineComponent_var comp = RetrieveSMESHInstance();
2171 myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
2174 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2176 // 0019923: EDF 765 SMESH : default values of hypothesis
2177 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2178 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2179 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2180 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2181 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2183 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2184 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2185 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2187 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2188 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2192 myActiveDialogBox = 0;
2193 myFilterLibraryDlg = 0;
2197 myEventCallbackCommand = vtkCallbackCommand::New();
2198 myEventCallbackCommand->Delete();
2199 myEventCallbackCommand->SetClientData( this );
2200 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2203 /* load resources for all available meshers */
2204 SMESH::InitAvailableHypotheses();
2207 //=============================================================================
2211 //=============================================================================
2212 SMESHGUI::~SMESHGUI()
2216 //=============================================================================
2220 //=============================================================================
2221 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2223 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2225 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2230 //=============================================================================
2234 //=============================================================================
2235 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2237 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2241 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2242 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2243 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2244 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2245 return autoUpdate && !exceeded;
2248 //=============================================================================
2252 //=============================================================================
2253 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2254 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2256 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2260 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2261 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2262 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2264 SMESH::long_array_var info = theMesh->GetMeshInfo();
2265 long nbOdElems = info[SMDSEntity_0D];
2266 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2267 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2268 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2269 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2270 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2271 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2272 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2273 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2274 info[SMDSEntity_Polyhedra] +
2275 info[SMDSEntity_Hexagonal_Prism];
2276 long nbBalls = info[SMDSEntity_Ball];
2278 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2279 *nbElements = requestedSize;
2281 *entities = SMESH_Actor::eAllEntity;
2284 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2286 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2288 if ( incrementalLimit ) {
2291 if ( nbOdElems > 0 ) {
2292 if ( total + nbOdElems > updateLimit ) {
2293 *entities = *entities & ~SMESH_Actor::e0DElements;
2294 *hidden = *hidden | SMESH_Actor::e0DElements;
2301 if ( nbEdges > 0 ) {
2302 if ( total + nbEdges > updateLimit ) {
2303 *entities = *entities & ~SMESH_Actor::eEdges;
2304 *hidden = *hidden | SMESH_Actor::eEdges;
2311 if ( nbFaces > 0 ) {
2312 if ( total + nbFaces > updateLimit ) {
2313 *entities = *entities & ~SMESH_Actor::eFaces;
2314 *hidden = *hidden | SMESH_Actor::eFaces;
2321 if ( nbVolumes > 0 ) {
2322 if ( total + nbVolumes > updateLimit ) {
2323 *entities = *entities & ~SMESH_Actor::eVolumes;
2324 *hidden = *hidden | SMESH_Actor::eVolumes;
2331 if ( nbBalls > 0 ) {
2332 if ( total + nbBalls > updateLimit ) {
2333 *entities = *entities & ~SMESH_Actor::eBallElem;
2334 *hidden = *hidden | SMESH_Actor::eBallElem;
2342 return autoUpdate && !exceeded;
2345 //=============================================================================
2349 //=============================================================================
2350 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2352 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2355 //=============================================================================
2359 //=============================================================================
2360 SMESHGUI* SMESHGUI::GetSMESHGUI()
2362 SMESHGUI* smeshMod = 0;
2363 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2366 CAM_Module* module = app->module( "Mesh" );
2367 smeshMod = dynamic_cast<SMESHGUI*>( module );
2375 Standard_EXPORT SMESHGUI* GetComponentGUI()
2377 return SMESHGUI::GetSMESHGUI();
2381 //=============================================================================
2385 //=============================================================================
2386 void SMESHGUI::SetState(int aState)
2391 //=============================================================================
2395 //=============================================================================
2396 void SMESHGUI::ResetState()
2401 //=============================================================================
2405 //=============================================================================
2406 void SMESHGUI::EmitSignalDeactivateDialog()
2408 emit SignalDeactivateActiveDialog();
2411 //=============================================================================
2415 //=============================================================================
2416 void SMESHGUI::EmitSignalStudyFrameChanged()
2418 emit SignalStudyFrameChanged();
2421 //=============================================================================
2425 //=============================================================================
2426 void SMESHGUI::EmitSignalCloseAllDialogs()
2428 emit SignalCloseAllDialogs();
2431 //=============================================================================
2435 //=============================================================================
2436 void SMESHGUI::EmitSignalVisibilityChanged()
2438 emit SignalVisibilityChanged();
2441 //=============================================================================
2445 //=============================================================================
2446 void SMESHGUI::EmitSignalCloseView()
2448 emit SignalCloseView();
2451 //=============================================================================
2455 //=============================================================================
2456 void SMESHGUI::EmitSignalActivatedViewManager()
2458 emit SignalActivatedViewManager();
2461 //=============================================================================
2465 //=============================================================================
2466 QDialog *SMESHGUI::GetActiveDialogBox()
2468 return myActiveDialogBox;
2471 //=============================================================================
2475 //=============================================================================
2476 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2478 myActiveDialogBox = (QDialog *) aDlg;
2482 //=============================================================================
2486 //=============================================================================
2487 SUIT_Desktop* SMESHGUI::desktop()
2489 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2491 return app->desktop();
2496 //=============================================================================
2500 //=============================================================================
2501 SalomeApp_Study* SMESHGUI::activeStudy()
2503 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2505 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2510 //=============================================================================
2514 //=============================================================================
2515 void SMESHGUI::Modified( bool theIsUpdateActions )
2517 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2518 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2519 appStudy->Modified();
2520 if( theIsUpdateActions )
2521 app->updateActions();
2526 //=============================================================================
2530 //=============================================================================
2531 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2533 /* Here the position is on the bottom right corner - 10 */
2534 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2536 SUIT_Desktop *PP = desktop();
2537 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2538 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2543 * \brief Verifies whether study of operation is locked
2544 * \param theMess - specifies whether message box must be shown if study is locked
2545 * \return State of study.
2547 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2548 * is locked when corresponding message box appears
2550 bool SMESHGUI::isStudyLocked( bool theMessage )
2552 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2555 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2556 QObject::tr( "WRN_WARNING" ),
2557 QObject::tr( "WRN_STUDY_LOCKED" ) );
2563 //=============================================================================
2567 //=============================================================================
2568 bool SMESHGUI::OnGUIEvent( int theCommandID )
2570 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2574 SUIT_ResourceMgr* mgr = resourceMgr();
2578 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2579 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2581 //QAction* act = action( theCommandID );
2583 switch (theCommandID) {
2584 case SMESHOp::OpDelete:
2585 if(isStudyLocked()) break;
2588 case SMESHOp::OpImportDAT:
2589 case SMESHOp::OpImportUNV:
2590 case SMESHOp::OpImportMED:
2591 case SMESHOp::OpImportSTL:
2592 case SMESHOp::OpImportCGNS:
2593 case SMESHOp::OpImportSAUV:
2594 case SMESHOp::OpImportGMF:
2595 case SMESHOp::OpPopupImportDAT:
2596 case SMESHOp::OpPopupImportUNV:
2597 case SMESHOp::OpPopupImportMED:
2598 case SMESHOp::OpPopupImportSTL:
2599 case SMESHOp::OpPopupImportCGNS:
2600 case SMESHOp::OpPopupImportSAUV:
2601 case SMESHOp::OpPopupImportGMF:
2603 if(isStudyLocked()) break;
2604 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2608 case SMESHOp::OpFileInformation:
2610 SALOME_ListIO selected;
2611 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2613 aSel->selectedObjects( selected );
2614 if( selected.Extent() )
2616 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2617 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2618 if ( !aMesh->_is_nil() )
2620 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2626 case SMESHOp::OpExportDAT:
2627 case SMESHOp::OpExportMED:
2628 case SMESHOp::OpExportUNV:
2629 case SMESHOp::OpExportSTL:
2630 case SMESHOp::OpExportCGNS:
2631 case SMESHOp::OpExportSAUV:
2632 case SMESHOp::OpExportGMF:
2633 case SMESHOp::OpPopupExportDAT:
2634 case SMESHOp::OpPopupExportMED:
2635 case SMESHOp::OpPopupExportUNV:
2636 case SMESHOp::OpPopupExportSTL:
2637 case SMESHOp::OpPopupExportCGNS:
2638 case SMESHOp::OpPopupExportSAUV:
2639 case SMESHOp::OpPopupExportGMF:
2641 ::ExportMeshToFile(theCommandID);
2645 case SMESHOp::OpReset: // SCALAR BAR
2647 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2648 SALOME_ListIO selected;
2650 aSel->selectedObjects( selected );
2652 SALOME_ListIteratorOfListIO it(selected);
2653 for( ; it.More(); it.Next()) {
2654 Handle(SALOME_InteractiveObject) anIO = it.Value();
2655 if( anIO->hasEntry() ) {
2656 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2657 anActor->SetControlMode( SMESH_Actor::eNone );
2658 #ifndef DISABLE_PLOT2DVIEWER
2659 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2661 anActor->UpdateFilter();
2665 SMESH::UpdateView();
2668 case SMESHOp::OpScalarBarProperties:
2670 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2673 case SMESHOp::OpShowScalarBar:
2675 // show/hide scalar bar
2676 ::ShowElement(theCommandID);
2679 case SMESHOp::OpSaveDistribution:
2681 // dump control distribution data to the text file
2682 ::SaveDistribution();
2686 case SMESHOp::OpShowDistribution:
2688 // show/hide distribution
2689 ::ShowElement(theCommandID);
2693 #ifndef DISABLE_PLOT2DVIEWER
2694 case SMESHOp::OpPlotDistribution:
2696 // plot distribution
2697 ::PlotDistribution();
2703 case SMESHOp::OpAutoColor:
2707 case SMESHOp::OpDisableAutoColor:
2708 ::DisableAutoColor();
2711 case SMESHOp::OpClipping:
2712 case SMESHOp::OpTransparency:
2713 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2716 case SMESHOp::OpDMWireframe:
2717 case SMESHOp::OpDMShading:
2718 case SMESHOp::OpDMNodes:
2719 case SMESHOp::OpDMShrink:
2720 ::SetDisplayMode(theCommandID, myMarkerMap);
2723 //2D quadratic representation
2724 case SMESHOp::OpRepresentationLines:
2725 case SMESHOp::OpRepresentationArcs:
2726 ::SetDisplayMode(theCommandID, myMarkerMap);
2730 case SMESHOp::OpDE0DElements:
2731 case SMESHOp::OpDEEdges:
2732 case SMESHOp::OpDEFaces:
2733 case SMESHOp::OpDEVolumes:
2734 case SMESHOp::OpDEBalls:
2735 case SMESHOp::OpDEAllEntity:
2736 ::SetDisplayEntity(theCommandID);
2739 // Choose entities to be displayed
2740 case SMESHOp::OpDEChoose:
2742 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2746 case SMESHOp::OpOrientationOnFaces:
2748 SUIT_OverrideCursor wc;
2749 LightApp_SelectionMgr* mgr = selectionMgr();
2750 SALOME_ListIO selected; mgr->selectedObjects( selected );
2752 SALOME_ListIteratorOfListIO it(selected);
2753 for( ; it.More(); it.Next()) {
2754 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2755 if(anIObject->hasEntry()) {
2756 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2757 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2764 case SMESHOp::OpUpdate:
2766 if(isStudyLocked()) break;
2767 SUIT_OverrideCursor wc;
2770 SMESH::UpdateView();
2772 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2773 SMESH::OnVisuException();
2775 catch (...) { // PAL16774 (Crash after display of many groups)
2776 SMESH::OnVisuException();
2780 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2781 aSel->selectedObjects( l );
2782 aSel->setSelectedObjects( l );
2786 case SMESHOp::OpHide:
2787 case SMESHOp::OpShow:
2788 case SMESHOp::OpShowOnly:
2790 SUIT_OverrideCursor wc;
2791 SMESH::EDisplaing anAction;
2792 switch (theCommandID) {
2793 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2794 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2795 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2798 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2799 SALOME_ListIO sel_objects, to_process;
2801 aSel->selectedObjects( sel_objects );
2803 if ( theCommandID==SMESHOp::OpShowOnly )
2805 //MESSAGE("anAction = SMESH::eDisplayOnly");
2806 startOperation( myEraseAll );
2809 extractContainers( sel_objects, to_process );
2814 SALOME_ListIteratorOfListIO It( to_process );
2815 for ( ; It.More(); It.Next())
2817 Handle(SALOME_InteractiveObject) IOS = It.Value();
2818 if ( IOS->hasEntry() )
2820 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2821 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2822 break; // PAL16774 (Crash after display of many groups)
2824 if (anAction == SMESH::eDisplayOnly)
2825 anAction = SMESH::eDisplay;
2830 // PAL13338 + PAL15161 -->
2831 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2832 SMESH::UpdateView();
2833 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2835 // PAL13338 + PAL15161 <--
2837 catch (...) { // PAL16774 (Crash after display of many groups)
2838 SMESH::OnVisuException();
2841 if (anAction == SMESH::eErase) {
2843 aSel->setSelectedObjects( l1 );
2846 aSel->setSelectedObjects( to_process );
2848 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2849 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2850 vtkwnd->GetRenderer()->AdjustActors();
2855 case SMESHOp::OpNode:
2857 if(isStudyLocked()) break;
2860 EmitSignalDeactivateDialog();
2862 ( new SMESHGUI_NodesDlg( this ) )->show();
2865 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2870 case SMESHOp::OpEditMeshOrSubMesh:
2871 case SMESHOp::OpEditMesh:
2872 case SMESHOp::OpEditSubMesh:
2873 case SMESHOp::OpMeshOrder:
2874 case SMESHOp::OpCreateSubMesh:
2875 if ( warnOnGeomModif() )
2876 break; // action forbidden as geometry modified
2878 case SMESHOp::OpCreateMesh:
2879 case SMESHOp::OpCompute:
2880 case SMESHOp::OpComputeSubMesh:
2881 case SMESHOp::OpPreCompute:
2882 case SMESHOp::OpEvaluate:
2883 case SMESHOp::OpShowErrors:
2884 startOperation( theCommandID );
2886 case SMESHOp::OpRecompute:
2888 if ( isStudyLocked() )
2890 SALOME_ListIO selected;
2891 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2892 sel->selectedObjects( selected );
2893 if ( selected.Extent() == 1 ) {
2894 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2895 if ( !aMesh->_is_nil() )
2897 startOperation( SMESHOp::OpCompute );
2901 case SMESHOp::OpCopyMesh:
2903 if (isStudyLocked()) break;
2904 EmitSignalDeactivateDialog();
2905 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2908 case SMESHOp::OpBuildCompoundMesh:
2910 if (isStudyLocked()) break;
2911 EmitSignalDeactivateDialog();
2912 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2916 case SMESHOp::OpDiagonalInversion:
2917 case SMESHOp::OpUnionOfTwoTriangle:
2921 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2925 if ( isStudyLocked() )
2927 if ( warnOnGeomModif() )
2928 break; // action forbidden as geometry modified
2930 /*Standard_Boolean aRes;
2931 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2932 if ( aMesh->_is_nil() )
2934 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2935 tr( "SMESH_BAD_SELECTION" ) );
2939 EmitSignalDeactivateDialog();
2940 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2941 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2943 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2946 case SMESHOp::OpOrientation:
2947 case SMESHOp::OpUnionOfTriangles:
2948 case SMESHOp::OpCuttingOfQuadrangles:
2949 case SMESHOp::OpSplitVolumes:
2953 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2957 if ( isStudyLocked() )
2959 if ( warnOnGeomModif() )
2960 break; // action forbidden as geometry modified
2962 EmitSignalDeactivateDialog();
2963 SMESHGUI_MultiEditDlg* aDlg = NULL;
2964 if ( theCommandID == SMESHOp::OpOrientation )
2965 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2966 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2967 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2968 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2969 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2971 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2976 case SMESHOp::OpSmoothing:
2978 if(isStudyLocked()) break;
2979 if ( warnOnGeomModif() )
2980 break; // action forbidden as geometry modified
2982 EmitSignalDeactivateDialog();
2983 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2986 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2990 case SMESHOp::OpExtrusion:
2992 if (isStudyLocked()) break;
2993 if ( warnOnGeomModif() )
2994 break; // action forbidden as geometry modified
2996 EmitSignalDeactivateDialog();
2997 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2999 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3003 case SMESHOp::OpExtrusionAlongAPath:
3005 if (isStudyLocked()) break;
3006 if ( warnOnGeomModif() )
3007 break; // action forbidden as geometry modified
3009 EmitSignalDeactivateDialog();
3010 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3012 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3016 case SMESHOp::OpRevolution:
3018 if(isStudyLocked()) break;
3019 if ( warnOnGeomModif() )
3020 break; // action forbidden as geometry modified
3022 EmitSignalDeactivateDialog();
3023 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3026 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3030 case SMESHOp::OpPatternMapping:
3032 if ( isStudyLocked() )
3034 if ( warnOnGeomModif() )
3035 break; // action forbidden as geometry modified
3038 EmitSignalDeactivateDialog();
3039 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3042 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3046 // Adaptation - begin
3047 #ifndef DISABLE_MG_ADAPT
3048 case SMESHOp::OpMGAdapt:
3050 if ( isStudyLocked() )
3052 EmitSignalDeactivateDialog();
3054 SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
3055 bool isCreation = false;
3056 ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
3061 case SMESHOp::OpSplitBiQuadratic:
3062 case SMESHOp::OpConvertMeshToQuadratic:
3063 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3064 case SMESHOp::OpReorientFaces:
3065 case SMESHOp::OpCreateGeometryGroup:
3067 if ( warnOnGeomModif() )
3068 break; // action forbidden as geometry modified
3069 startOperation( theCommandID );
3072 case SMESHOp::OpCreateGroup:
3076 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3080 if(isStudyLocked()) break;
3081 if ( warnOnGeomModif() )
3082 break; // action forbidden as geometry modified
3083 EmitSignalDeactivateDialog();
3084 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3086 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3087 SALOME_ListIO selected;
3089 aSel->selectedObjects( selected );
3091 int nbSel = selected.Extent();
3093 // check if mesh is selected
3094 aMesh = SMESH::GetMeshByIO( selected.First() );
3096 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3101 case SMESHOp::OpConstructGroup:
3105 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3109 if(isStudyLocked()) break;
3110 if ( warnOnGeomModif() )
3111 break; // action forbidden as geometry modified
3112 EmitSignalDeactivateDialog();
3114 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3115 SALOME_ListIO selected;
3117 aSel->selectedObjects( selected );
3119 int nbSel = selected.Extent();
3121 // check if submesh is selected
3122 Handle(SALOME_InteractiveObject) IObject = selected.First();
3123 if (IObject->hasEntry()) {
3124 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3126 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3127 if (!aSubMesh->_is_nil()) {
3129 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3130 // get submesh elements list by types
3131 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3132 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3133 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3134 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3135 // create group for each type o elements
3136 QString aName = IObject->getName();
3137 QStringList anEntryList;
3138 if (aNodes->length() > 0) {
3139 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3140 aGroup->Add(aNodes.inout());
3141 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3142 anEntryList.append( aSObject->GetID().c_str() );
3144 if (aEdges->length() > 0) {
3145 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3146 aGroup->Add(aEdges.inout());
3147 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3148 anEntryList.append( aSObject->GetID().c_str() );
3150 if (aFaces->length() > 0) {
3151 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3152 aGroup->Add(aFaces.inout());
3153 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3154 anEntryList.append( aSObject->GetID().c_str() );
3156 if (aVolumes->length() > 0) {
3157 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3158 aGroup->Add(aVolumes.inout());
3159 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3160 anEntryList.append( aSObject->GetID().c_str() );
3163 anApp->browseObjects( anEntryList );
3165 catch(const SALOME::SALOME_Exception & S_ex){
3166 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3173 SUIT_MessageBox::warning(desktop(),
3174 tr("SMESH_WRN_WARNING"),
3175 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3180 case SMESHOp::OpEditGroup:
3184 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3188 if(isStudyLocked()) break;
3189 if ( warnOnGeomModif() )
3190 break; // action forbidden as geometry modified
3191 EmitSignalDeactivateDialog();
3193 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3194 SALOME_ListIO selected;
3196 aSel->selectedObjects( selected );
3198 SALOME_ListIteratorOfListIO It (selected);
3199 int nbSelectedGroups = 0;
3200 for ( ; It.More(); It.Next() )
3202 SMESH::SMESH_GroupBase_var aGroup =
3203 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3204 if (!aGroup->_is_nil()) {
3206 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3210 if (nbSelectedGroups == 0)
3212 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3218 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3220 if(isStudyLocked()) break;
3221 if (myState == 800) {
3222 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3223 if (aDlg) aDlg->onAdd();
3228 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3230 if(isStudyLocked()) break;
3231 if (myState == 800) {
3232 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3233 if (aDlg) aDlg->onRemove();
3238 case SMESHOp::OpEditGeomGroupAsGroup:
3242 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3246 if(isStudyLocked()) break;
3247 EmitSignalDeactivateDialog();
3249 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3250 SALOME_ListIO selected;
3252 aSel->selectedObjects( selected );
3254 SALOME_ListIteratorOfListIO It (selected);
3255 for ( ; It.More(); It.Next() )
3257 SMESH::SMESH_GroupOnGeom_var aGroup =
3258 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3259 if (!aGroup->_is_nil()) {
3260 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3265 SMESH::SMESH_GroupOnFilter_var aGroup =
3266 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3267 if (!aGroup->_is_nil()) {
3268 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3276 case SMESHOp::OpUnionGroups:
3277 case SMESHOp::OpIntersectGroups:
3278 case SMESHOp::OpCutGroups:
3282 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3286 if ( isStudyLocked() )
3288 if ( warnOnGeomModif() )
3289 break; // action forbidden as geometry modified
3291 EmitSignalDeactivateDialog();
3293 SMESHGUI_GroupOpDlg* aDlg = 0;
3294 if ( theCommandID == SMESHOp::OpUnionGroups )
3295 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3296 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3297 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3299 aDlg = new SMESHGUI_CutGroupsDlg( this );
3306 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3308 if ( isStudyLocked() )
3310 if ( warnOnGeomModif() )
3311 break; // action forbidden as geometry modified
3313 EmitSignalDeactivateDialog();
3314 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3320 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3322 if ( isStudyLocked() )
3324 if ( warnOnGeomModif() )
3325 break; // action forbidden as geometry modified
3327 EmitSignalDeactivateDialog();
3328 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3334 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3338 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3342 if ( isStudyLocked() )
3345 EmitSignalDeactivateDialog();
3347 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3351 case SMESHOp::OpMeshInformation:
3352 case SMESHOp::OpWhatIs:
3354 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3355 EmitSignalDeactivateDialog();
3356 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3357 SALOME_ListIO selected;
3359 aSel->selectedObjects( selected );
3361 if ( selected.Extent() > 1 ) { // a dlg for each IO
3362 SALOME_ListIteratorOfListIO It( selected );
3363 for ( ; It.More(); It.Next() ) {
3364 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3365 dlg->showInfo( It.Value() );
3370 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3376 case SMESHOp::OpFindElementByPoint:
3378 startOperation( theCommandID );
3382 case SMESHOp::OpEditHypothesis:
3384 if(isStudyLocked()) break;
3385 if ( warnOnGeomModif() )
3386 break; // action forbidden as geometry modified
3388 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3389 SALOME_ListIO selected;
3391 aSel->selectedObjects( selected );
3393 int nbSel = selected.Extent();
3396 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3397 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3399 if ( !aHypothesis->_is_nil() )
3401 SMESHGUI_GenericHypothesisCreator* aCreator =
3402 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3405 // set geometry of mesh and sub-mesh to aCreator
3406 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3407 if ( selected.Extent() == 1 )
3409 QString subGeomID, meshGeomID;
3410 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3411 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3413 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3414 aCreator->setShapeEntry( subGeomID );
3415 aCreator->setMainShapeEntry( meshGeomID );
3419 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3429 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3431 if(isStudyLocked()) break;
3432 if ( warnOnGeomModif() )
3433 break; // action forbidden as geometry modified
3434 SUIT_OverrideCursor wc;
3436 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3437 SALOME_ListIO selected;
3439 aSel->selectedObjects( selected, QString::null, false );
3441 SALOME_ListIteratorOfListIO It(selected);
3442 for (int i = 0; It.More(); It.Next(), i++) {
3443 Handle(SALOME_InteractiveObject) IObject = It.Value();
3444 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3447 aSel->setSelectedObjects( l1 );
3452 case SMESHOp::OpElem0D:
3453 case SMESHOp::OpBall:
3454 case SMESHOp::OpEdge:
3455 case SMESHOp::OpTriangle:
3456 case SMESHOp::OpQuadrangle:
3457 case SMESHOp::OpPolygon:
3458 case SMESHOp::OpTetrahedron:
3459 case SMESHOp::OpHexahedron:
3460 case SMESHOp::OpPentahedron:
3461 case SMESHOp::OpPyramid:
3462 case SMESHOp::OpHexagonalPrism:
3464 if(isStudyLocked()) break;
3465 if ( warnOnGeomModif() )
3466 break; // action forbidden as geometry modified
3468 EmitSignalDeactivateDialog();
3469 SMDSAbs_EntityType type = SMDSEntity_Edge;
3470 switch (theCommandID) {
3471 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3472 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3473 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3474 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3475 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3476 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3477 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3478 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3479 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3480 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3483 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3486 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3490 case SMESHOp::OpPolyhedron:
3492 if(isStudyLocked()) break;
3493 if ( warnOnGeomModif() )
3494 break; // action forbidden as geometry modified
3496 EmitSignalDeactivateDialog();
3497 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3500 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3504 case SMESHOp::OpQuadraticEdge:
3505 case SMESHOp::OpQuadraticTriangle:
3506 case SMESHOp::OpBiQuadraticTriangle:
3507 case SMESHOp::OpQuadraticQuadrangle:
3508 case SMESHOp::OpBiQuadraticQuadrangle:
3509 case SMESHOp::OpQuadraticPolygon:
3510 case SMESHOp::OpQuadraticTetrahedron:
3511 case SMESHOp::OpQuadraticPyramid:
3512 case SMESHOp::OpQuadraticPentahedron:
3513 case SMESHOp::OpBiQuadraticPentahedron:
3514 case SMESHOp::OpQuadraticHexahedron:
3515 case SMESHOp::OpTriQuadraticHexahedron:
3517 if(isStudyLocked()) break;
3518 if ( warnOnGeomModif() )
3519 break; // action forbidden as geometry modified
3521 EmitSignalDeactivateDialog();
3522 SMDSAbs_EntityType type = SMDSEntity_Last;
3524 switch (theCommandID) {
3525 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3526 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3527 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3528 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3529 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3530 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3531 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3532 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3533 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3534 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3535 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3536 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3539 if ( type != SMDSEntity_Last )
3540 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3543 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3544 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3548 case SMESHOp::OpRemoveNodes:
3550 if(isStudyLocked()) break;
3551 if ( warnOnGeomModif() )
3552 break; // action forbidden as geometry modified
3554 EmitSignalDeactivateDialog();
3555 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3558 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3559 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3563 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3565 if(isStudyLocked()) break;
3566 if ( warnOnGeomModif() )
3567 break; // action forbidden as geometry modified
3569 EmitSignalDeactivateDialog();
3570 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3574 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3575 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3579 case SMESHOp::OpClearMesh: {
3581 if(isStudyLocked()) break;
3582 if ( warnOnGeomModif() )
3583 break; // action forbidden as geometry modified
3585 SALOME_ListIO selected;
3586 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3587 aSel->selectedObjects( selected );
3589 SUIT_OverrideCursor wc;
3590 SALOME_ListIteratorOfListIO It (selected);
3591 for ( ; It.More(); It.Next() )
3593 Handle(SALOME_InteractiveObject) IOS = It.Value();
3594 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3595 if ( aMesh->_is_nil()) continue;
3598 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3599 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3600 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3601 // hide groups and submeshes
3602 _PTR(ChildIterator) anIter =
3603 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3604 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3606 _PTR(SObject) so = anIter->Value();
3607 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3610 catch (const SALOME::SALOME_Exception& S_ex){
3612 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3616 SMESH::UpdateView();
3620 case SMESHOp::OpRemoveOrphanNodes:
3622 if(isStudyLocked()) break;
3623 if ( warnOnGeomModif() )
3624 break; // action forbidden as geometry modified
3625 SALOME_ListIO selected;
3626 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3627 aSel->selectedObjects( selected );
3628 if ( selected.Extent() == 1 ) {
3629 Handle(SALOME_InteractiveObject) anIO = selected.First();
3630 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3631 if ( !aMesh->_is_nil() ) {
3632 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3633 tr( "SMESH_WARNING" ),
3634 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3635 SUIT_MessageBox::Yes |
3636 SUIT_MessageBox::No,
3637 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3640 SUIT_OverrideCursor wc;
3641 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3642 int removed = aMeshEditor->RemoveOrphanNodes();
3643 SUIT_MessageBox::information(SMESHGUI::desktop(),
3644 tr("SMESH_INFORMATION"),
3645 tr("NB_NODES_REMOVED").arg(removed));
3646 if ( removed > 0 ) {
3647 SMESH::UpdateView();
3648 SMESHGUI::Modified();
3651 catch (const SALOME::SALOME_Exception& S_ex) {
3652 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3661 case SMESHOp::OpRenumberingNodes:
3663 if(isStudyLocked()) break;
3664 if ( warnOnGeomModif() )
3665 break; // action forbidden as geometry modified
3667 EmitSignalDeactivateDialog();
3668 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3672 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3673 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3677 case SMESHOp::OpRenumberingElements:
3679 if(isStudyLocked()) break;
3680 if ( warnOnGeomModif() )
3681 break; // action forbidden as geometry modified
3683 EmitSignalDeactivateDialog();
3684 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3688 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3689 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3693 case SMESHOp::OpTranslation:
3695 if(isStudyLocked()) break;
3696 if ( warnOnGeomModif() )
3697 break; // action forbidden as geometry modified
3699 EmitSignalDeactivateDialog();
3700 ( new SMESHGUI_TranslationDlg( this ) )->show();
3703 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3704 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3708 case SMESHOp::OpRotation:
3710 if(isStudyLocked()) break;
3711 if ( warnOnGeomModif() )
3712 break; // action forbidden as geometry modified
3714 EmitSignalDeactivateDialog();
3715 ( new SMESHGUI_RotationDlg( this ) )->show();
3718 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3719 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3723 case SMESHOp::OpSymmetry:
3725 if(isStudyLocked()) break;
3726 if ( warnOnGeomModif() )
3727 break; // action forbidden as geometry modified
3729 EmitSignalDeactivateDialog();
3730 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3733 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3734 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3738 case SMESHOp::OpScale:
3740 if(isStudyLocked()) break;
3741 if ( warnOnGeomModif() )
3742 break; // action forbidden as geometry modified
3744 EmitSignalDeactivateDialog();
3745 ( new SMESHGUI_ScaleDlg( this ) )->show();
3748 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3749 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3754 case SMESHOp::OpOffset:
3756 if(isStudyLocked()) break;
3757 if ( warnOnGeomModif() )
3758 break; // action forbidden as geometry modified
3760 EmitSignalDeactivateDialog();
3761 ( new SMESHGUI_OffsetDlg( this ) )->show();
3764 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3765 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3770 case SMESHOp::OpSewing:
3772 if(isStudyLocked()) break;
3773 if ( warnOnGeomModif() )
3774 break; // action forbidden as geometry modified
3776 EmitSignalDeactivateDialog();
3777 ( new SMESHGUI_SewingDlg( this ) )->show();
3780 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3781 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3785 case SMESHOp::OpMergeNodes:
3787 if(isStudyLocked()) break;
3788 if ( warnOnGeomModif() )
3789 break; // action forbidden as geometry modified
3791 EmitSignalDeactivateDialog();
3792 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3795 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3796 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3800 case SMESHOp::OpMergeElements:
3802 if (isStudyLocked()) break;
3803 if ( warnOnGeomModif() )
3804 break; // action forbidden as geometry modified
3806 EmitSignalDeactivateDialog();
3807 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3809 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3810 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3815 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3816 if ( warnOnGeomModif() )
3817 break; // action forbidden as geometry modified
3818 startOperation( SMESHOp::OpMoveNode );
3821 case SMESHOp::OpDuplicateNodes:
3823 if(isStudyLocked()) break;
3824 if ( warnOnGeomModif() )
3825 break; // action forbidden as geometry modified
3827 EmitSignalDeactivateDialog();
3828 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3831 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3832 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3837 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3838 if ( warnOnGeomModif() )
3839 break; // action forbidden as geometry modified
3840 startOperation( SMESHOp::OpElem0DOnElemNodes );
3843 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3845 static QList<int> aTypes;
3846 if ( aTypes.isEmpty() )
3848 aTypes.append( SMESH::NODE );
3849 aTypes.append( SMESH::EDGE );
3850 aTypes.append( SMESH::FACE );
3851 aTypes.append( SMESH::VOLUME );
3853 if (!myFilterLibraryDlg)
3854 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3855 else if (myFilterLibraryDlg->isHidden())
3856 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3857 myFilterLibraryDlg->raise();
3861 case SMESHOp::OpFreeNode:
3862 case SMESHOp::OpEqualNode:
3863 case SMESHOp::OpNodeConnectivityNb:
3864 case SMESHOp::OpFreeEdge:
3865 case SMESHOp::OpFreeBorder:
3866 case SMESHOp::OpLength:
3867 case SMESHOp::OpConnection:
3868 case SMESHOp::OpEqualEdge:
3869 case SMESHOp::OpFreeFace:
3870 case SMESHOp::OpBareBorderFace:
3871 case SMESHOp::OpOverConstrainedFace:
3872 case SMESHOp::OpLength2D:
3873 case SMESHOp::OpDeflection2D:
3874 case SMESHOp::OpConnection2D:
3875 case SMESHOp::OpArea:
3876 case SMESHOp::OpTaper:
3877 case SMESHOp::OpAspectRatio:
3878 case SMESHOp::OpMinimumAngle:
3879 case SMESHOp::OpWarpingAngle:
3880 case SMESHOp::OpSkew:
3881 case SMESHOp::OpMaxElementLength2D:
3882 case SMESHOp::OpEqualFace:
3883 case SMESHOp::OpAspectRatio3D:
3884 case SMESHOp::OpVolume:
3885 case SMESHOp::OpMaxElementLength3D:
3886 case SMESHOp::OpBareBorderVolume:
3887 case SMESHOp::OpOverConstrainedVolume:
3888 case SMESHOp::OpEqualVolume:
3891 LightApp_SelectionMgr* mgr = selectionMgr();
3892 SALOME_ListIO selected; mgr->selectedObjects( selected );
3894 if( !selected.IsEmpty() ) {
3895 SUIT_OverrideCursor wc;
3896 ::Control( theCommandID );
3899 SUIT_MessageBox::warning(desktop(),
3900 tr( "SMESH_WRN_WARNING" ),
3901 tr( "SMESH_BAD_SELECTION" ) );
3905 SUIT_MessageBox::warning(desktop(),
3906 tr( "SMESH_WRN_WARNING" ),
3907 tr( "NOT_A_VTK_VIEWER" ) );
3910 case SMESHOp::OpOverallMeshQuality:
3911 OverallMeshQuality();
3913 case SMESHOp::OpNumberingNodes:
3915 SUIT_OverrideCursor wc;
3916 LightApp_SelectionMgr* mgr = selectionMgr();
3917 SALOME_ListIO selected; mgr->selectedObjects( selected );
3919 SALOME_ListIteratorOfListIO it(selected);
3920 for( ; it.More(); it.Next()) {
3921 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3922 if(anIObject->hasEntry()) {
3923 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3924 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3930 case SMESHOp::OpNumberingElements:
3932 SUIT_OverrideCursor wc;
3933 LightApp_SelectionMgr* mgr = selectionMgr();
3934 SALOME_ListIO selected; mgr->selectedObjects( selected );
3936 SALOME_ListIteratorOfListIO it(selected);
3937 for( ; it.More(); it.Next()) {
3938 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3939 if(anIObject->hasEntry())
3940 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3941 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3946 case SMESHOp::OpPropertiesLength:
3947 case SMESHOp::OpPropertiesArea:
3948 case SMESHOp::OpPropertiesVolume:
3949 case SMESHOp::OpMinimumDistance:
3950 case SMESHOp::OpBoundingBox:
3951 case SMESHOp::OpAngle:
3953 int page = SMESHGUI_MeasureDlg::MinDistance;
3954 if ( theCommandID == SMESHOp::OpBoundingBox )
3955 page = SMESHGUI_MeasureDlg::BoundingBox;
3956 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3957 page = SMESHGUI_MeasureDlg::Length;
3958 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3959 page = SMESHGUI_MeasureDlg::Area;
3960 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3961 page = SMESHGUI_MeasureDlg::Volume;
3962 else if ( theCommandID == SMESHOp::OpAngle )
3963 page = SMESHGUI_MeasureDlg::Angle;
3965 EmitSignalDeactivateDialog();
3966 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3970 case SMESHOp::OpSortChild:
3973 case SMESHOp::OpBreakLink:
3974 ::breakShaperLink();
3979 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3980 //updateObjBrowser();
3984 //=============================================================================
3988 //=============================================================================
3989 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3994 //=============================================================================
3998 //=============================================================================
3999 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4004 //=============================================================================
4008 //=============================================================================
4009 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4014 //=============================================================================
4015 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4016 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4018 //=============================================================================
4019 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4020 SUIT_ViewWindow* wnd )
4022 if(theIO->hasEntry()){
4023 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4024 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4028 //=======================================================================
4029 // function : createSMESHAction
4031 //=======================================================================
4032 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4033 const int key, const bool toggle, const QString& shortcutAction )
4036 QWidget* parent = application()->desktop();
4037 SUIT_ResourceMgr* resMgr = resourceMgr();
4039 if ( !icon_id.isEmpty() )
4040 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4042 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4043 if ( !pix.isNull() )
4044 icon = QIcon( pix );
4046 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4047 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4048 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4050 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4051 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4054 //=======================================================================
4055 // function : createPopupItem
4057 //=======================================================================
4058 void SMESHGUI::createPopupItem( const int id,
4059 const QString& clients,
4060 const QString& types,
4061 const QString& theRule,
4064 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4065 popupMgr()->insert( action( id ), pId, 0 );
4067 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4068 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4069 QString rule = "(%1) and (%2) and (%3)";
4070 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4071 if( clients.isEmpty() )
4072 rule = rule.arg( QString( "true" ) );
4074 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4075 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4078 bool cont = myRules.contains( id );
4080 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4082 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4083 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4086 //=======================================================================
4087 // function : initialize
4089 //=======================================================================
4090 void SMESHGUI::initialize( CAM_Application* app )
4092 SalomeApp_Module::initialize( app );
4094 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4096 /* Automatic Update flag */
4097 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4099 // ----- create actions --------------
4101 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4102 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4103 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4104 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4106 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4108 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4109 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4110 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4111 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4112 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4114 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4116 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4117 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4119 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4120 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4121 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4122 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4124 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4126 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4127 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4128 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4129 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4130 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4131 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4133 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4135 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4136 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4137 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4138 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4139 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4140 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4141 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4142 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4143 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4144 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4145 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4146 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4147 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4148 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4149 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4150 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4151 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4152 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4153 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4154 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4155 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4156 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4157 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4158 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4159 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4160 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4161 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4162 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4163 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4164 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4165 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4166 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4167 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4168 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4169 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4170 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4172 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4173 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4174 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4175 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4176 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4177 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4178 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4179 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4180 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4181 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4182 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4183 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4184 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4185 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4186 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4187 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4188 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4189 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4190 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4191 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4192 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4193 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4194 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4195 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4196 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4197 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4198 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4199 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4200 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4202 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4203 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4204 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4205 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4206 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4207 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4208 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4209 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4210 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4211 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4212 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4213 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4214 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4215 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4216 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4217 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4218 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4219 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4220 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4221 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4222 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4223 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4224 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4225 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4226 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4227 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4229 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4230 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4231 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4232 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4234 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4235 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4237 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4238 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4239 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4240 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4241 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4242 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4243 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4244 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4245 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4246 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4247 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4248 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4249 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4250 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4251 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4252 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4253 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4254 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4255 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4256 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4257 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4258 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4259 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4260 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4261 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4263 createSMESHAction( SMESHOp::OpReset, "RESET" );
4264 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4265 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4266 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4267 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4268 #ifndef DISABLE_PLOT2DVIEWER
4269 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4271 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4272 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4273 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4274 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4275 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4276 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4277 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4278 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4279 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4280 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4281 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4282 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4283 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4285 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4286 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4288 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4289 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4290 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4291 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4292 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4293 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4294 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4295 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4296 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4298 // Adaptation - begin
4299 #ifndef DISABLE_MG_ADAPT
4300 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4304 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4305 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4306 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4307 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4308 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4309 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4311 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4312 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4313 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4315 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4317 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4319 QList<int> aCtrlActions;
4320 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4321 << SMESHOp::OpNodeConnectivityNb // node controls
4322 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4323 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4324 << SMESHOp::OpDeflection2D
4325 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4326 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4327 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4328 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4329 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4330 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4331 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4332 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4333 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4334 aCtrlGroup->setExclusive( true );
4335 for( int i = 0; i < aCtrlActions.size(); i++ )
4336 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4338 // ----- create menu --------------
4339 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4340 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4341 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4342 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4343 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4344 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4345 #ifndef DISABLE_MG_ADAPT
4346 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4348 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4349 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4351 createMenu( separator(), fileId );
4353 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4354 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4355 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4356 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4357 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4358 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4359 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4360 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4361 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4362 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4363 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4364 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4365 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4367 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4368 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4369 createMenu( SMESHOp::OpImportMED, importId, -1 );
4370 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4372 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4374 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4375 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4376 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4377 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4378 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4379 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4381 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4383 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4384 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4385 createMenu( separator(), fileId, 10 );
4387 createMenu( SMESHOp::OpDelete, editId, -1 );
4389 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4391 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4392 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4393 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4394 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4395 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4396 createMenu( separator(), meshId, -1 );
4397 createMenu( SMESHOp::OpCompute, meshId, -1 );
4398 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4399 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4400 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4401 createMenu( separator(), meshId, -1 );
4402 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4403 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4404 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4405 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4406 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4407 createMenu( separator(), meshId, -1 );
4408 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4409 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4410 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4411 createMenu( separator(), meshId, -1 );
4412 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4413 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4414 createMenu( separator(), meshId, -1 );
4415 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4416 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4417 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4418 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4419 createMenu( separator(), meshId, -1 );
4421 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4422 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4423 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4424 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4425 createMenu( SMESHOp::OpLength, edgeId, -1 );
4426 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4427 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4428 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4429 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4430 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4431 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4432 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4433 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4434 createMenu( SMESHOp::OpArea, faceId, -1 );
4435 createMenu( SMESHOp::OpTaper, faceId, -1 );
4436 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4437 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4438 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4439 createMenu( SMESHOp::OpSkew, faceId, -1 );
4440 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4441 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4442 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4443 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4444 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4445 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4446 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4447 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4448 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4449 createMenu( separator(), ctrlId, -1 );
4450 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4451 createMenu( separator(), ctrlId, -1 );
4452 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4454 createMenu( SMESHOp::OpNode, addId, -1 );
4455 createMenu( SMESHOp::OpElem0D, addId, -1 );
4456 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4457 createMenu( SMESHOp::OpBall, addId, -1 );
4458 createMenu( SMESHOp::OpEdge, addId, -1 );
4459 createMenu( SMESHOp::OpTriangle, addId, -1 );
4460 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4461 createMenu( SMESHOp::OpPolygon, addId, -1 );
4462 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4463 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4464 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4465 createMenu( SMESHOp::OpPyramid, addId, -1 );
4466 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4467 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4468 createMenu( separator(), addId, -1 );
4469 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4470 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4471 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4472 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4473 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4474 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4475 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4476 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4477 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4478 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4479 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4480 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4482 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4483 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4484 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4485 createMenu( separator(), removeId, -1 );
4486 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4487 createMenu( separator(), removeId, -1 );
4488 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4490 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4491 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4493 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4494 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4495 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4496 createMenu( SMESHOp::OpRotation, transfId, -1 );
4497 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4498 createMenu( SMESHOp::OpScale, transfId, -1 );
4499 createMenu( SMESHOp::OpOffset, transfId, -1 );
4500 createMenu( SMESHOp::OpSewing, transfId, -1 );
4501 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4503 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4504 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4505 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4506 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4507 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4508 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4509 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4510 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4511 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4512 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4513 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4514 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4515 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4516 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4517 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4518 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4520 // Adaptation - begin
4521 #ifndef DISABLE_MG_ADAPT
4522 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4526 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4527 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4528 createMenu( SMESHOp::OpAngle, measureId, -1 );
4529 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4530 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4531 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4532 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4534 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4535 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4536 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4537 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4539 // ----- create toolbars --------------
4540 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4541 createTool( SMESHOp::OpCreateMesh, meshTb );
4542 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4543 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4544 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4545 createTool( SMESHOp::OpCopyMesh, meshTb );
4546 createTool( separator(), meshTb );
4547 createTool( SMESHOp::OpCompute, meshTb );
4548 createTool( SMESHOp::OpPreCompute, meshTb );
4549 createTool( SMESHOp::OpEvaluate, meshTb );
4550 createTool( SMESHOp::OpMeshOrder, meshTb );
4552 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4553 createTool( SMESHOp::OpMeshInformation, infoTb );
4554 //createTool( SMESHOp::OpStdInfo, meshTb );
4555 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4556 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4558 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4559 createTool( SMESHOp::OpCreateGroup, groupTb );
4560 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4561 createTool( SMESHOp::OpConstructGroup, groupTb );
4562 createTool( SMESHOp::OpEditGroup, groupTb );
4564 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4565 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4566 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4567 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4569 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4570 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4571 createTool( SMESHOp::OpLength, ctrl1dTb );
4572 createTool( SMESHOp::OpConnection, ctrl1dTb );
4573 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4575 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4576 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4577 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4578 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4579 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4580 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4581 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4582 createTool( SMESHOp::OpArea, ctrl2dTb );
4583 createTool( SMESHOp::OpTaper, ctrl2dTb );
4584 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4585 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4586 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4587 createTool( SMESHOp::OpSkew, ctrl2dTb );
4588 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4589 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4590 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4592 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4593 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4594 createTool( SMESHOp::OpVolume, ctrl3dTb );
4595 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4596 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4597 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4598 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4600 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4601 createTool( SMESHOp::OpNode, addElemTb );
4602 createTool( SMESHOp::OpElem0D, addElemTb );
4603 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4604 createTool( SMESHOp::OpBall, addElemTb );
4605 createTool( SMESHOp::OpEdge, addElemTb );
4606 createTool( SMESHOp::OpTriangle, addElemTb );
4607 createTool( SMESHOp::OpQuadrangle, addElemTb );
4608 createTool( SMESHOp::OpPolygon, addElemTb );
4609 createTool( SMESHOp::OpTetrahedron, addElemTb );
4610 createTool( SMESHOp::OpHexahedron, addElemTb );
4611 createTool( SMESHOp::OpPentahedron, addElemTb );
4612 createTool( SMESHOp::OpPyramid, addElemTb );
4613 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4614 createTool( SMESHOp::OpPolyhedron, addElemTb );
4616 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4617 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4618 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4619 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4620 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4621 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4622 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4623 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4624 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4625 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4626 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4627 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4628 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4630 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4631 createTool( SMESHOp::OpRemoveNodes, remTb );
4632 createTool( SMESHOp::OpRemoveElements, remTb );
4633 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4634 createTool( SMESHOp::OpClearMesh, remTb );
4636 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4637 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4638 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4640 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4641 createTool( SMESHOp::OpMergeNodes, transformTb );
4642 createTool( SMESHOp::OpMergeElements, transformTb );
4643 createTool( SMESHOp::OpTranslation, transformTb );
4644 createTool( SMESHOp::OpRotation, transformTb );
4645 createTool( SMESHOp::OpSymmetry, transformTb );
4646 createTool( SMESHOp::OpScale, transformTb );
4647 createTool( SMESHOp::OpOffset, transformTb );
4648 createTool( SMESHOp::OpSewing, transformTb );
4649 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4651 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4652 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4653 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4654 createTool( SMESHOp::OpExtrusion, modifyTb );
4655 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4656 createTool( SMESHOp::OpRevolution, modifyTb );
4657 createTool( SMESHOp::OpOrientation, modifyTb );
4658 createTool( SMESHOp::OpReorientFaces, modifyTb );
4659 createTool( SMESHOp::OpMoveNode, modifyTb );
4660 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4661 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4662 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4663 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4664 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4665 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4666 createTool( SMESHOp::OpSmoothing, modifyTb );
4667 createTool( SMESHOp::OpPatternMapping, modifyTb );
4669 // Adaptation - begin
4670 #ifndef DISABLE_MG_ADAPT
4671 int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
4672 createTool( SMESHOp::OpMGAdapt, adaptTb );
4676 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4677 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4679 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4680 createTool( SMESHOp::OpUpdate, dispModeTb );
4682 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4683 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4687 OB = "'ObjectBrowser'",
4688 View = "'" + SVTK_Viewer::Type() + "'",
4690 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4691 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4692 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4693 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4694 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4695 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4696 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4697 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4698 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4699 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4700 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4701 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4703 mesh_part = mesh + " " + subMesh + " " + group,
4704 mesh_group = mesh + " " + group,
4705 mesh_submesh = mesh + " " + subMesh,
4706 hyp_alg = hypo + " " + algo;
4708 // popup for object browser
4710 isInvisible("not( isVisible )"),
4711 isEmpty("numberOfNodes = 0"),
4712 isNotEmpty("numberOfNodes <> 0"),
4714 // has nodes, edges, etc in VISIBLE! actor
4715 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4716 hasElems("(count( elemTypes ) > 0)"),
4717 hasDifferentElems("(count( elemTypes ) > 1)"),
4718 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4719 hasBalls("({'BallElem'} in elemTypes)"),
4720 hasElems0d("({'Elem0d'} in elemTypes)"),
4721 hasEdges("({'Edge'} in elemTypes)"),
4722 hasFaces("({'Face'} in elemTypes)"),
4723 hasVolumes("({'Volume'} in elemTypes)"),
4724 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4726 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4727 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4728 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4729 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4730 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4731 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4733 popupMgr()->insert( separator(), -1, 0 );
4734 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4735 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4736 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4737 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4738 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4739 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4740 popupMgr()->insert( separator(), -1, 0 );
4741 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4742 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4743 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4744 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4745 popupMgr()->insert( separator(), -1, 0 );
4746 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4747 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4748 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4749 popupMgr()->insert( separator(), -1, 0 );
4750 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4751 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4752 popupMgr()->insert( separator(), -1, 0 );
4753 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4754 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4756 // Adaptation - begin
4757 #ifndef DISABLE_MG_ADAPT
4758 popupMgr()->insert( separator(), -1, 0 );
4759 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4760 popupMgr()->insert( separator(), -1, 0 );
4764 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4765 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4766 QString only_one_2D = only_one_non_empty + " && dim>1";
4768 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4769 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4770 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4771 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4772 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4774 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4776 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4777 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4778 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4780 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4781 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4782 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4783 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4785 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4787 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4788 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4789 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4790 popupMgr()->insert( separator(), -1, 0 );
4792 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4793 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4794 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4797 createPopupItem( SMESHOp::OpEditGroup, View, group );
4798 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4799 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4801 popupMgr()->insert( separator(), -1, 0 );
4802 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4803 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4804 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4805 popupMgr()->insert( separator(), -1, 0 );
4807 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4808 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4809 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4810 popupMgr()->insert( separator(), -1, 0 );
4812 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4813 QString aType = QString( "%1type in {%2}" ).arg( lc );
4814 aType = aType.arg( mesh_part );
4815 QString aMeshInVTK = aClient + "&&" + aType;
4817 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4818 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4819 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4821 //-------------------------------------------------
4823 //-------------------------------------------------
4824 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4826 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4827 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4828 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4830 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4831 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4832 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4834 popupMgr()->insert( separator(), -1, -1 );
4836 //-------------------------------------------------
4838 //-------------------------------------------------
4839 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4841 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4842 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4843 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4845 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4846 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4847 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4849 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4850 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4851 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4853 popupMgr()->insert( separator(), anId, -1 );
4855 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4856 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4857 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4859 //-------------------------------------------------
4861 //-------------------------------------------------
4862 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4864 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4866 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4867 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4868 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4870 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4871 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4872 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4874 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4875 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4876 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4878 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4879 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4880 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4882 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4883 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4884 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4886 popupMgr()->insert( separator(), anId, -1 );
4888 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4889 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4891 popupMgr()->insert( separator(), anId, -1 );
4893 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4894 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4897 //-------------------------------------------------
4898 // Representation of the 2D Quadratic elements
4899 //-------------------------------------------------
4900 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4901 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4902 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4903 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4905 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4906 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4907 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4909 //-------------------------------------------------
4910 // Orientation of faces
4911 //-------------------------------------------------
4912 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4913 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4914 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4916 //-------------------------------------------------
4918 //-------------------------------------------------
4919 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4920 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4922 //-------------------------------------------------
4924 //-------------------------------------------------
4925 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4926 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4928 //-------------------------------------------------
4930 //-------------------------------------------------
4932 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4933 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4934 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4935 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4937 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4939 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4940 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4942 popupMgr()->insert( separator(), anId, -1 );
4944 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4946 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4947 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4948 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4950 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4951 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4952 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4954 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4955 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4956 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4958 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4960 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4961 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4962 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4964 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4965 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4966 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4968 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4969 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4970 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4971 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4972 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4973 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4975 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4977 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4978 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4979 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4981 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4982 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4983 QtxPopupMgr::VisibleRule );
4984 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4986 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4987 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4988 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4990 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4991 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4992 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4994 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4995 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4996 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4998 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4999 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5000 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
5002 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
5003 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5004 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5006 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5007 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5008 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5010 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5011 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5012 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5014 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5015 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5016 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5018 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5019 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5020 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5022 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5023 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5024 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5026 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5027 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5028 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5030 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5031 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5032 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5034 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5035 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5036 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5038 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5040 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5041 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5042 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5044 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5045 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5046 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5048 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5049 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5050 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5052 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5053 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5054 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5056 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5057 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5058 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5060 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5061 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5062 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5064 popupMgr()->insert( separator(), anId, -1 );
5066 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5067 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5068 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5069 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5070 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5072 popupMgr()->insert( separator(), anId, -1 );
5074 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5076 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5077 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5079 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5080 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5081 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5083 #ifndef DISABLE_PLOT2DVIEWER
5084 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5085 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5088 //-------------------------------------------------
5090 //-------------------------------------------------
5091 popupMgr()->insert( separator(), -1, -1 );
5092 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5093 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5094 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5095 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5097 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5098 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5100 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5101 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5103 popupMgr()->insert( separator(), -1, -1 );
5105 //-------------------------------------------------
5107 //-------------------------------------------------
5108 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5109 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5111 popupMgr()->insert( separator(), -1, -1 );
5113 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5114 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5115 popupMgr()->insert( separator(), -1, -1 );
5117 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5118 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5120 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5121 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5123 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5124 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5127 //================================================================================
5129 * \brief Return true if SMESH or GEOM objects are selected.
5130 * Is called form LightApp_Module::activateModule() which clear selection if
5131 * not isSelectionCompatible()
5133 //================================================================================
5135 bool SMESHGUI::isSelectionCompatible()
5137 bool isCompatible = true;
5138 SALOME_ListIO selected;
5139 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5140 Sel->selectedObjects( selected );
5142 SALOME_ListIteratorOfListIO It( selected );
5143 for ( ; isCompatible && It.More(); It.Next())
5145 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5146 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5147 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5149 return isCompatible;
5153 bool SMESHGUI::reusableOperation( const int id )
5155 // compute, evaluate and precompute are not reusable operations
5156 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5161 QString wrap(const QString& text, const QString& tag)
5162 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5165 bool SMESHGUI::activateModule( SUIT_Study* study )
5167 bool res = SalomeApp_Module::activateModule( study );
5169 setMenuShown( true );
5170 setToolShown( true );
5172 // Fill in Help Panel
5173 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5174 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5176 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5179 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5180 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5181 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5182 lab = lab + tr("INFO_REFINE") + ":";
5183 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5184 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5185 lab = lab + wrap(items.join(""), "ul");
5188 app->infoPanel()->addLabel(lab, gb);
5190 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5191 items << wrap("UNV", "li")
5192 << wrap("MED", "li")
5193 << wrap("STL", "li")
5194 << wrap("CGNS", "li")
5195 << wrap("SAUV", "li")
5196 << wrap("GMF", "li");
5197 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5200 app->infoPanel()->addLabel(lab, gb);
5202 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5203 lab = tr("INFO_DISPLAY") + "<br/>";
5204 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5205 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5206 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5207 << wrap("...", "li");
5208 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5210 lab = lab + tr("INFO_CLIPPING");
5212 app->infoPanel()->addLabel(lab, gb);
5215 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5216 PyGILState_STATE gstate = PyGILState_Ensure();
5217 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5218 if ( !pluginsmanager ) {
5222 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5227 PyGILState_Release(gstate);
5228 // end of SMESH plugins loading
5230 // Reset actions accelerator keys
5231 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5233 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5234 GetSMESHGen()->UpdateStudy();
5236 // get all view currently opened in the study and connect their signals to
5237 // the corresponding slots of the class.
5238 SUIT_Desktop* aDesk = study->application()->desktop();
5240 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5241 SUIT_ViewWindow* wnd;
5242 foreach ( wnd, wndList )
5246 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5247 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5253 Py_XDECREF(pluginsmanager);
5257 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5259 setMenuShown( false );
5260 setToolShown( false );
5262 EmitSignalCloseAllDialogs();
5264 // Unset actions accelerator keys
5265 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5267 return SalomeApp_Module::deactivateModule( study );
5270 void SMESHGUI::studyClosed( SUIT_Study* s )
5274 SMESH::RemoveVisuData();
5275 SalomeApp_Module::studyClosed( s );
5278 void SMESHGUI::OnGUIEvent()
5280 const QObject* obj = sender();
5281 if ( !obj || !obj->inherits( "QAction" ) )
5283 int id = actionId((QAction*)obj);
5288 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5290 if ( CORBA::is_nil( myComponentSMESH ) )
5292 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5293 return aGUI.myComponentSMESH;
5295 return myComponentSMESH;
5298 QString SMESHGUI::engineIOR() const
5300 CORBA::ORB_var anORB = getApp()->orb();
5301 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5302 return QString( anIOR.in() );
5305 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5307 SalomeApp_Module::contextMenuPopup( client, menu, title );
5309 selectionMgr()->selectedObjects( lst );
5310 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5311 Handle(SALOME_InteractiveObject) io = lst.First();
5312 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5313 _PTR(Study) study = appStudy->studyDS();
5314 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5316 QString aName = SMESH::fromUtf8( obj->GetName());
5317 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5318 aName.remove(( aName.length() - 1 ), 1 );
5324 LightApp_Selection* SMESHGUI::createSelection() const
5326 return new SMESHGUI_Selection();
5329 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5331 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5332 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5333 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5334 #ifndef DISABLE_PYCONSOLE
5335 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5339 void SMESHGUI::viewManagers( QStringList& list ) const
5341 list.append( SVTK_Viewer::Type() );
5344 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5346 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5347 SMESH::UpdateSelectionProp( this );
5349 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5350 for(int i = 0; i < aViews.count() ; i++){
5351 SUIT_ViewWindow *sf = aViews[i];
5354 EmitSignalActivatedViewManager();
5358 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5360 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5361 myClippingPlaneInfoMap.erase( theViewManager );
5364 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5366 theActor->AddObserver( SMESH::DeleteActorEvent,
5367 myEventCallbackCommand.GetPointer(),
5371 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5372 unsigned long theEvent,
5373 void* theClientData,
5374 void* /*theCallData*/ )
5376 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5377 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5378 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5379 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5380 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5381 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5382 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5383 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5384 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5385 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5386 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5387 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5388 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5389 if( anActor == *anIter3 ) {
5390 anActorList.erase( anIter3 );
5401 void SMESHGUI::createPreferences()
5403 // General tab ------------------------------------------------------------------------
5404 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5406 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5407 setPreferenceProperty( autoUpdate, "columns", 2 );
5408 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5409 setPreferenceProperty( lim, "min", 0 );
5410 setPreferenceProperty( lim, "max", 100000000 );
5411 setPreferenceProperty( lim, "step", 1000 );
5412 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5413 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5415 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5416 setPreferenceProperty( dispgroup, "columns", 2 );
5418 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5420 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5422 modes.append( tr("MEN_WIRE") );
5423 modes.append( tr("MEN_SHADE") );
5424 modes.append( tr("MEN_NODES") );
5425 modes.append( tr("MEN_SHRINK") );
5426 QList<QVariant> indices;
5427 indices.append( 0 );
5428 indices.append( 1 );
5429 indices.append( 2 );
5430 indices.append( 3 );
5431 setPreferenceProperty( dispmode, "strings", modes );
5432 setPreferenceProperty( dispmode, "indexes", indices );
5434 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5435 setPreferenceProperty( arcgroup, "columns", 2 );
5436 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5437 QStringList quadraticModes;
5438 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5439 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5441 indices.append( 0 );
5442 indices.append( 1 );
5443 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5444 setPreferenceProperty( quadraticmode, "indexes", indices );
5446 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5447 "SMESH", "max_angle" );
5448 setPreferenceProperty( maxAngle, "min", 1 );
5449 setPreferenceProperty( maxAngle, "max", 90 );
5451 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5452 setPreferenceProperty( qaGroup, "columns", 2 );
5453 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5454 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5455 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5456 setPreferenceProperty( prec, "min", 0 );
5457 setPreferenceProperty( prec, "max", 100 );
5458 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5459 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5460 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5461 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5462 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5465 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5466 setPreferenceProperty( cinc, "min", 0 );
5467 setPreferenceProperty( cinc, "max", 5 );
5470 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5471 setPreferenceProperty( exportgroup, "columns", 2 );
5472 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5473 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5474 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5475 setPreferenceProperty( zTol, "precision", 10 );
5476 setPreferenceProperty( zTol, "min", 0.0000000001 );
5477 setPreferenceProperty( zTol, "max", 1000000.0 );
5478 setPreferenceProperty( zTol, "step", 1. );
5479 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5481 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5482 setPreferenceProperty( computeGroup, "columns", 2 );
5483 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5485 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5486 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5487 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5489 indices.append( 0 );
5490 indices.append( 1 );
5491 indices.append( 2 );
5492 setPreferenceProperty( notifyMode, "strings", modes );
5493 setPreferenceProperty( notifyMode, "indexes", indices );
5495 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5496 setPreferenceProperty( infoGroup, "columns", 2 );
5497 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5499 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5500 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5502 indices.append( 0 );
5503 indices.append( 1 );
5504 setPreferenceProperty( elemInfo, "strings", modes );
5505 setPreferenceProperty( elemInfo, "indexes", indices );
5506 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5507 setPreferenceProperty( nodesLim, "min", 0 );
5508 setPreferenceProperty( nodesLim, "max", 10000000 );
5509 setPreferenceProperty( nodesLim, "step", 10000 );
5510 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5511 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5512 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5513 setPreferenceProperty( ctrlLim, "min", 0 );
5514 setPreferenceProperty( ctrlLim, "max", 10000000 );
5515 setPreferenceProperty( ctrlLim, "step", 1000 );
5516 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5517 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5518 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5519 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5520 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5522 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5523 setPreferenceProperty( segGroup, "columns", 2 );
5524 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5525 "SMESH", "segmentation" );
5526 setPreferenceProperty( segLen, "min", 1 );
5527 setPreferenceProperty( segLen, "max", 10000000 );
5528 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5529 "SMESH", "nb_segments_per_edge" );
5530 setPreferenceProperty( nbSeg, "min", 1 );
5531 setPreferenceProperty( nbSeg, "max", 10000000 );
5532 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5534 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5535 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5536 "SMESH", "forget_mesh_on_hyp_modif" );
5539 // Quantities with individual precision settings
5540 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5541 setPreferenceProperty( precGroup, "columns", 2 );
5543 const int nbQuantities = 6;
5544 int precs[nbQuantities], ii = 0;
5545 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5546 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5547 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5548 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5549 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5550 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5551 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5552 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5553 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5554 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5555 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5556 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5558 // Set property for precision value for spinboxes
5559 for ( ii = 0; ii < nbQuantities; ii++ ){
5560 setPreferenceProperty( precs[ii], "min", -14 );
5561 setPreferenceProperty( precs[ii], "max", 14 );
5562 setPreferenceProperty( precs[ii], "precision", 2 );
5565 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5566 setPreferenceProperty( previewGroup, "columns", 2 );
5567 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5568 setPreferenceProperty( chunkSize, "min", 1 );
5569 setPreferenceProperty( chunkSize, "max", 1000 );
5570 setPreferenceProperty( chunkSize, "step", 50 );
5572 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5573 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5575 // Mesh tab ------------------------------------------------------------------------
5576 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5577 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5578 setPreferenceProperty( nodeGroup, "columns", 3 );
5580 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5582 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5584 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5585 QList<QVariant> aMarkerTypeIndicesList;
5586 QList<QVariant> aMarkerTypeIconsList;
5587 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5588 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5589 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5590 aMarkerTypeIndicesList << i;
5591 aMarkerTypeIconsList << pixmap;
5593 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5594 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5596 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5598 QList<QVariant> aMarkerScaleIndicesList;
5599 QStringList aMarkerScaleValuesList;
5600 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5601 aMarkerScaleIndicesList << i;
5602 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5603 aMarkerScaleValuesList << QString::number( i );
5605 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5606 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5608 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5609 //setPreferenceProperty( elemGroup, "columns", 2 );
5611 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5612 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5613 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5614 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5615 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5616 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5617 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5618 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5619 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5622 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5623 setPreferenceProperty( grpGroup, "columns", 2 );
5625 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5626 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5628 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5629 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5630 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5631 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5632 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5633 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5634 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5635 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5636 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5637 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5638 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5639 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5640 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5641 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5643 setPreferenceProperty( size0d, "min", 1 );
5644 setPreferenceProperty( size0d, "max", 10 );
5646 // setPreferenceProperty( ballSize, "min", 1 );
5647 // setPreferenceProperty( ballSize, "max", 10 );
5649 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5650 setPreferenceProperty( ballDiameter, "max", 1e9 );
5651 setPreferenceProperty( ballDiameter, "step", 0.1 );
5653 setPreferenceProperty( ballScale, "min", 1e-2 );
5654 setPreferenceProperty( ballScale, "max", 1e7 );
5655 setPreferenceProperty( ballScale, "step", 0.5 );
5657 setPreferenceProperty( elemW, "min", 1 );
5658 setPreferenceProperty( elemW, "max", 5 );
5660 setPreferenceProperty( outW, "min", 1 );
5661 setPreferenceProperty( outW, "max", 5 );
5663 setPreferenceProperty( shrink, "min", 0 );
5664 setPreferenceProperty( shrink, "max", 100 );
5666 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5667 setPreferenceProperty( numGroup, "columns", 2 );
5669 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5670 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5672 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5673 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5675 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5676 setPreferenceProperty( orientGroup, "columns", 1 );
5678 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5679 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5681 setPreferenceProperty( orientScale, "min", 0.05 );
5682 setPreferenceProperty( orientScale, "max", 0.5 );
5683 setPreferenceProperty( orientScale, "step", 0.05 );
5685 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5687 // Selection tab ------------------------------------------------------------------------
5688 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5690 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5691 setPreferenceProperty( selGroup, "columns", 2 );
5693 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5694 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5696 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5697 setPreferenceProperty( preGroup, "columns", 2 );
5699 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5701 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5702 setPreferenceProperty( precSelGroup, "columns", 2 );
5704 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5705 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5706 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5708 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5709 setPreferenceProperty( sinc, "min", 0 );
5710 setPreferenceProperty( sinc, "max", 5 );
5712 // Scalar Bar tab ------------------------------------------------------------------------
5713 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5714 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5715 setPreferenceProperty( fontGr, "columns", 2 );
5717 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5718 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5720 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5721 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5723 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5724 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5726 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5727 setPreferenceProperty( numcol, "min", 2 );
5728 setPreferenceProperty( numcol, "max", 256 );
5730 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5731 setPreferenceProperty( numlab, "min", 2 );
5732 setPreferenceProperty( numlab, "max", 65 );
5734 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5735 setPreferenceProperty( orientGr, "columns", 2 );
5736 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5737 QStringList orients;
5738 orients.append( tr( "SMESH_VERTICAL" ) );
5739 orients.append( tr( "SMESH_HORIZONTAL" ) );
5740 indices.clear(); indices.append( 0 ); indices.append( 1 );
5741 setPreferenceProperty( orient, "strings", orients );
5742 setPreferenceProperty( orient, "indexes", indices );
5744 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5745 setPreferenceProperty( posVSizeGr, "columns", 2 );
5746 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5747 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5748 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5749 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5750 setPreferenceProperty( xv, "step", 0.1 );
5751 setPreferenceProperty( xv, "min", 0.0 );
5752 setPreferenceProperty( xv, "max", 1.0 );
5753 setPreferenceProperty( yv, "step", 0.1 );
5754 setPreferenceProperty( yv, "min", 0.0 );
5755 setPreferenceProperty( yv, "max", 1.0 );
5756 setPreferenceProperty( wv, "step", 0.1 );
5757 setPreferenceProperty( wv, "min", 0.0 );
5758 setPreferenceProperty( wv, "max", 1.0 );
5759 setPreferenceProperty( hv, "min", 0.0 );
5760 setPreferenceProperty( hv, "max", 1.0 );
5761 setPreferenceProperty( hv, "step", 0.1 );
5763 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5764 setPreferenceProperty( posHSizeGr, "columns", 2 );
5765 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5766 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5767 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5768 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5769 setPreferenceProperty( xv, "min", 0.0 );
5770 setPreferenceProperty( xv, "max", 1.0 );
5771 setPreferenceProperty( xv, "step", 0.1 );
5772 setPreferenceProperty( xh, "min", 0.0 );
5773 setPreferenceProperty( xh, "max", 1.0 );
5774 setPreferenceProperty( xh, "step", 0.1 );
5775 setPreferenceProperty( yh, "min", 0.0 );
5776 setPreferenceProperty( yh, "max", 1.0 );
5777 setPreferenceProperty( yh, "step", 0.1 );
5778 setPreferenceProperty( wh, "min", 0.0 );
5779 setPreferenceProperty( wh, "max", 1.0 );
5780 setPreferenceProperty( wh, "step", 0.1 );
5781 setPreferenceProperty( hh, "min", 0.0 );
5782 setPreferenceProperty( hh, "max", 1.0 );
5783 setPreferenceProperty( hh, "step", 0.1 );
5785 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5786 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5787 setPreferenceProperty( distributionGr, "columns", 3 );
5789 types.append( tr( "SMESH_MONOCOLOR" ) );
5790 types.append( tr( "SMESH_MULTICOLOR" ) );
5791 indices.clear(); indices.append( 0 ); indices.append( 1 );
5792 setPreferenceProperty( coloringType, "strings", types );
5793 setPreferenceProperty( coloringType, "indexes", indices );
5794 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5796 // Adaptation - begin
5797 #ifndef DISABLE_MG_ADAPT
5798 // Adaptation tab ------------------------------------------------------------------------
5799 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5802 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5803 setPreferenceProperty( bloc, "columns", 1 );
5804 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5805 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5806 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5807 QStringList aListOfSizeMap;
5808 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5809 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5810 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5811 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5812 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5813 QStringList aListOfTimeStep;
5814 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5815 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5816 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5817 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5822 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5824 if ( sect=="SMESH" ) {
5825 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5826 float aTol = 1.00000009999999;
5827 std::string aWarning;
5828 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5830 if ( name == "selection_object_color" ||
5831 name == "selection_element_color" ||
5832 name == "highlight_color" ||
5833 name == "selection_precision_node" ||
5834 name == "selection_precision_element" ||
5835 name == "selection_precision_object" ||
5836 name == "selection_increment")
5838 SMESH::UpdateSelectionProp( this );
5840 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5842 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5843 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5844 if ( sbX1+sbW > aTol ) {
5845 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5848 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5849 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5852 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5854 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5855 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5856 if ( sbY1 + sbH > aTol ) {
5857 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5858 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5859 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5862 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5864 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5865 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5866 if ( sbX1 + sbW > aTol ) {
5867 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5870 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5871 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5874 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5876 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5877 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5878 if ( sbY1 + sbH > aTol ) {
5879 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5882 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5883 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5886 else if ( name == "segmentation" )
5888 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5889 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5891 else if ( name == "nb_segments_per_edge" )
5893 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5894 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5896 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5898 QString val = aResourceMgr->stringValue( "SMESH", name );
5899 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5901 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5903 SMESH::UpdateFontProp( this );
5905 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5907 SMESH::UpdateFontProp( this );
5910 if ( aWarning.size() != 0 ) {
5911 aWarning += "The default values are applied instead.";
5912 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5913 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5914 QObject::tr(aWarning.c_str()));
5919 //================================================================================
5921 * \brief Update something in accordance with update flags
5922 * \param theFlags - update flags
5924 * Update viewer or/and object browser etc. in accordance with update flags ( see
5925 * LightApp_UpdateFlags enumeration ).
5927 //================================================================================
5928 void SMESHGUI::update( const int flags )
5930 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5931 SMESH::UpdateView();
5933 SalomeApp_Module::update( flags );
5936 //================================================================================
5938 * \brief Set default selection mode
5940 * SLOT called when operation committed. Sets default selection mode
5942 //================================================================================
5943 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5945 SVTK_ViewWindow* vtkWnd =
5946 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5948 vtkWnd->SetSelectionMode( ActorSelection );
5951 //================================================================================
5953 * \brief Set default selection mode
5955 * SLOT called when operation aborted. Sets default selection mode
5957 //================================================================================
5958 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5960 SVTK_ViewWindow* vtkWnd =
5961 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5963 vtkWnd->SetSelectionMode( ActorSelection );
5966 //================================================================================
5968 * \brief Creates operation with given identifier
5969 * \param id - identifier of operation to be started
5970 * \return Pointer on created operation or NULL if operation is not created
5972 * Virtual method redefined from the base class creates operation with given id.
5973 * It is called called automatically from startOperation method of base class.
5975 //================================================================================
5976 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5978 LightApp_Operation* op = 0;
5979 // to do : create operation here
5982 case SMESHOp::OpSplitBiQuadratic:
5983 op = new SMESHGUI_SplitBiQuadOp();
5985 case SMESHOp::OpConvertMeshToQuadratic:
5986 op = new SMESHGUI_ConvToQuadOp();
5988 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5989 op = new SMESHGUI_Make2DFrom3DOp();
5991 case SMESHOp::OpReorientFaces:
5992 op = new SMESHGUI_ReorientFacesOp();
5994 case SMESHOp::OpCreateMesh:
5995 op = new SMESHGUI_MeshOp( true, true );
5997 case SMESHOp::OpCreateSubMesh:
5998 op = new SMESHGUI_MeshOp( true, false );
6000 case SMESHOp::OpEditMeshOrSubMesh:
6001 case SMESHOp::OpEditMesh:
6002 case SMESHOp::OpEditSubMesh:
6003 op = new SMESHGUI_MeshOp( false );
6005 case SMESHOp::OpCompute:
6006 case SMESHOp::OpComputeSubMesh:
6007 op = new SMESHGUI_ComputeOp();
6009 case SMESHOp::OpShowErrors:
6010 op = new SMESHGUI_ShowErrorsOp();
6012 case SMESHOp::OpPreCompute:
6013 op = new SMESHGUI_PrecomputeOp();
6015 case SMESHOp::OpEvaluate:
6016 op = new SMESHGUI_EvaluateOp();
6018 case SMESHOp::OpMeshOrder:
6019 op = new SMESHGUI_MeshOrderOp();
6021 case SMESHOp::OpCreateGeometryGroup:
6022 op = new SMESHGUI_GroupOnShapeOp();
6024 case SMESHOp::OpFindElementByPoint:
6025 op = new SMESHGUI_FindElemByPointOp();
6027 case SMESHOp::OpMoveNode: // Make mesh pass through point
6028 op = new SMESHGUI_MakeNodeAtPointOp();
6030 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6031 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6038 op = SalomeApp_Module::createOperation( id );
6042 //================================================================================
6044 * \brief Stops current operations and starts a given one
6045 * \param id - The id of the operation to start
6047 //================================================================================
6049 void SMESHGUI::switchToOperation(int id)
6051 activeStudy()->abortAllOperations();
6052 startOperation( id );
6055 LightApp_Displayer* SMESHGUI::displayer()
6058 myDisplayer = new SMESHGUI_Displayer( getApp() );
6062 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6065 int aTolerance = 64;
6066 int anIterations = 0;
6072 if( anIterations % aPeriod == 0 )
6075 if( aTolerance < 1 )
6079 aHue = (int)( 360.0 * rand() / RAND_MAX );
6082 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6083 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6084 for( ; it != itEnd; ++it )
6086 SALOMEDS::Color anAutoColor = *it;
6087 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6090 aQColor.getHsv( &h, &s, &v );
6091 if( abs( h - aHue ) < aTolerance )
6103 aColor.setHsv( aHue, 255, 255 );
6105 SALOMEDS::Color aSColor;
6106 aSColor.R = aColor.redF();
6107 aSColor.G = aColor.greenF();
6108 aSColor.B = aColor.blueF();
6113 const char* gSeparator = "_"; // character used to separate parameter names
6114 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6115 const char* gPathSep = "|"; // character used to separate paths
6118 * \brief Store visual parameters
6120 * This method is called just before the study document is saved.
6121 * Store visual parameters in AttributeParameter attribute(s)
6123 void SMESHGUI::storeVisualParameters (int savePoint)
6126 Kernel_Utils::Localizer loc;
6128 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6129 if (!appStudy || !appStudy->studyDS())
6131 _PTR(Study) studyDS = appStudy->studyDS();
6133 // componentName is used for encoding of entries when storing them in IParameters
6134 std::string componentName = myComponentSMESH->ComponentDataType();
6135 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6136 //if (!aSComponent) return;
6139 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6140 componentName.c_str(),
6142 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6144 // store custom markers
6145 if( !myMarkerMap.empty() )
6147 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6148 for( ; anIter != myMarkerMap.end(); anIter++ )
6150 int anId = anIter->first;
6151 VTK::MarkerData aMarkerData = anIter->second;
6152 std::string aMarkerFileName = aMarkerData.first;
6153 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6154 if( aMarkerTexture.size() < 3 )
6155 continue; // should contain at least width, height and the first value
6157 QString aPropertyName( "texture" );
6158 aPropertyName += gSeparator;
6159 aPropertyName += QString::number( anId );
6161 QString aPropertyValue = aMarkerFileName.c_str();
6162 aPropertyValue += gPathSep;
6164 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6165 ushort aWidth = *aTextureIter++;
6166 ushort aHeight = *aTextureIter++;
6167 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6168 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6169 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6170 aPropertyValue += QString::number( *aTextureIter );
6172 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6176 // viewers counters are used for storing view_numbers in IParameters
6179 // main cycle to store parameters of displayed objects
6180 QList<SUIT_ViewManager*> lst;
6181 QList<SUIT_ViewManager*>::Iterator it;
6182 getApp()->viewManagers(lst);
6183 for (it = lst.begin(); it != lst.end(); it++)
6185 SUIT_ViewManager* vman = *it;
6186 QString vType = vman->getType();
6188 // saving VTK actors properties
6189 if (vType == SVTK_Viewer::Type())
6191 // store the clipping planes attached to the view manager
6192 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6193 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6194 if( anIter != myClippingPlaneInfoMap.end() )
6195 aClippingPlaneInfoList = anIter->second;
6197 if( !aClippingPlaneInfoList.empty() ) {
6198 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6199 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6201 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6202 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6204 QString aPropertyName( "ClippingPlane" );
6205 aPropertyName += gSeparator;
6206 aPropertyName += QString::number( vtkViewers );
6207 aPropertyName += gSeparator;
6208 aPropertyName += QString::number( anId );
6210 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6211 aPropertyValue += gDigitsSep;
6212 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6213 aPropertyValue += gDigitsSep;
6214 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6215 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6216 aPropertyValue += gDigitsSep;
6217 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6218 aPropertyValue += gDigitsSep;
6219 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6220 aPropertyValue += gDigitsSep;
6221 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6222 aPropertyValue += gDigitsSep;
6223 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6224 aPropertyValue += gDigitsSep;
6225 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6226 aPropertyValue += gDigitsSep;
6227 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6229 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6230 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6231 aPropertyValue += gDigitsSep;
6232 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6233 aPropertyValue += gDigitsSep;
6234 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6235 aPropertyValue += gDigitsSep;
6236 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6239 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6243 QVector<SUIT_ViewWindow*> views = vman->getViews();
6244 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6246 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6248 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6249 vtkActorCollection* allActors = aCopy.GetActors();
6250 allActors->InitTraversal();
6251 while (vtkActor* actor = allActors->GetNextActor())
6253 if (actor->GetVisibility()) // store only visible actors
6255 SMESH_Actor* aSmeshActor = 0;
6256 if (actor->IsA("SMESH_Actor"))
6257 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6258 if (aSmeshActor && aSmeshActor->hasIO())
6260 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6263 // entry is "encoded" = it does NOT contain component address,
6264 // since it is a subject to change on next component loading
6265 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6267 std::string param, vtkParam = vType.toLatin1().data();
6268 vtkParam += gSeparator;
6269 vtkParam += QString::number(vtkViewers).toLatin1().data();
6270 vtkParam += gSeparator;
6273 param = vtkParam + "Visibility";
6274 ip->setParameter(entry, param, "On");
6277 param = vtkParam + "Representation";
6278 ip->setParameter(entry, param, QString::number
6279 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6282 param = vtkParam + "IsShrunk";
6283 ip->setParameter(entry, param, QString::number
6284 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6286 // Displayed entities
6287 unsigned int aMode = aSmeshActor->GetEntityMode();
6288 bool isE = aMode & SMESH_Actor::eEdges;
6289 bool isF = aMode & SMESH_Actor::eFaces;
6290 bool isV = aMode & SMESH_Actor::eVolumes;
6291 bool is0d = aMode & SMESH_Actor::e0DElements;
6292 bool isB = aMode & SMESH_Actor::eBallElem;
6294 QString modeStr ("e");
6295 modeStr += gDigitsSep; modeStr += QString::number(isE);
6296 modeStr += gDigitsSep; modeStr += "f";
6297 modeStr += gDigitsSep; modeStr += QString::number(isF);
6298 modeStr += gDigitsSep; modeStr += "v";
6299 modeStr += gDigitsSep; modeStr += QString::number(isV);
6300 modeStr += gDigitsSep; modeStr += "0d";
6301 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6302 modeStr += gDigitsSep; modeStr += "b";
6303 modeStr += gDigitsSep; modeStr += QString::number(isB);
6305 param = vtkParam + "Entities";
6306 ip->setParameter(entry, param, modeStr.toLatin1().data());
6312 aSmeshActor->GetSufaceColor(r, g, b, delta);
6313 QStringList colorStr;
6314 colorStr << "surface";
6315 colorStr << QString::number(r);
6316 colorStr << QString::number(g);
6317 colorStr << QString::number(b);
6319 colorStr << "backsurface";
6320 colorStr << QString::number(delta);
6322 aSmeshActor->GetVolumeColor(r, g, b, delta);
6323 colorStr << "volume";
6324 colorStr << QString::number(r);
6325 colorStr << QString::number(g);
6326 colorStr << QString::number(b);
6327 colorStr << QString::number(delta);
6329 aSmeshActor->GetEdgeColor(r, g, b);
6331 colorStr << QString::number(r);
6332 colorStr << QString::number(g);
6333 colorStr << QString::number(b);
6335 aSmeshActor->GetNodeColor(r, g, b);
6337 colorStr << QString::number(r);
6338 colorStr << QString::number(g);
6339 colorStr << QString::number(b);
6341 aSmeshActor->GetOutlineColor(r, g, b);
6342 colorStr << "outline";
6343 colorStr << QString::number(r);
6344 colorStr << QString::number(g);
6345 colorStr << QString::number(b);
6347 aSmeshActor->Get0DColor(r, g, b);
6348 colorStr << "elem0d";
6349 colorStr << QString::number(r);
6350 colorStr << QString::number(g);
6351 colorStr << QString::number(b);
6353 aSmeshActor->GetBallColor(r, g, b);
6355 colorStr << QString::number(r);
6356 colorStr << QString::number(g);
6357 colorStr << QString::number(b);
6359 aSmeshActor->GetFacesOrientationColor(r, g, b);
6360 colorStr << "orientation";
6361 colorStr << QString::number(r);
6362 colorStr << QString::number(g);
6363 colorStr << QString::number(b);
6365 param = vtkParam + "Colors";
6366 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6369 QStringList sizeStr;
6371 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6372 sizeStr << "outline";
6373 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6374 sizeStr << "elem0d";
6375 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6377 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6378 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6379 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6380 sizeStr << "shrink";
6381 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6382 sizeStr << "orientation";
6383 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6384 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6386 param = vtkParam + "Sizes";
6387 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6392 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6393 if( aMarkerType == VTK::MT_USER ) {
6394 markerStr += "custom";
6395 markerStr += gDigitsSep;
6396 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6400 markerStr += gDigitsSep;
6401 markerStr += QString::number( (int)aMarkerType );
6402 markerStr += gDigitsSep;
6403 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6406 param = vtkParam + "PointMarker";
6407 ip->setParameter(entry, param, markerStr.toLatin1().data());
6410 param = vtkParam + "Opacity";
6411 ip->setParameter(entry, param,
6412 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6415 param = vtkParam + "ClippingPlane";
6417 if( !aClippingPlaneInfoList.empty() ) {
6418 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6419 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6421 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6422 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6423 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6424 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6425 if( aSmeshActor == *anIter2 ) {
6426 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6427 QString::number( anId ).toLatin1().constData() );
6434 ip->setParameter( entry, param, "Off" );
6435 } // if (io->hasEntry())
6436 } // SMESH_Actor && hasIO
6438 } // while.. actors traversal
6442 } // if (SVTK view model)
6443 } // for (viewManagers)
6446 // data structures for clipping planes processing
6450 bool isOpenGLClipping;
6451 vtkIdType RelativeOrientation;
6454 int AbsoluteOrientation;
6455 double X, Y, Z, Dx, Dy, Dz;
6457 typedef std::list<TPlaneData> TPlaneDataList;
6458 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6460 typedef std::list<vtkActor*> TActorList;
6463 TActorList ActorList;
6464 SUIT_ViewManager* ViewManager;
6466 typedef std::list<TPlaneInfo> TPlaneInfoList;
6467 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6470 * \brief Restore visual parameters
6472 * This method is called after the study document is opened.
6473 * Restore visual parameters from AttributeParameter attribute(s)
6475 void SMESHGUI::restoreVisualParameters (int savePoint)
6478 Kernel_Utils::Localizer loc;
6480 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6481 if (!appStudy || !appStudy->studyDS())
6483 _PTR(Study) studyDS = appStudy->studyDS();
6485 // componentName is used for encoding of entries when storing them in IParameters
6486 std::string componentName = myComponentSMESH->ComponentDataType();
6489 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6490 componentName.c_str(),
6492 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6494 // restore custom markers and map of clipping planes
6495 TPlaneDataMap aPlaneDataMap;
6497 std::vector<std::string> properties = ip->getProperties();
6498 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6500 std::string property = *propIt;
6501 QString aPropertyName( property.c_str() );
6502 QString aPropertyValue( ip->getProperty( property ).c_str() );
6504 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6505 if( aPropertyNameList.isEmpty() )
6508 QString aPropertyType = aPropertyNameList[0];
6509 if( aPropertyType == "texture" )
6511 if( aPropertyNameList.size() != 2 )
6515 int anId = aPropertyNameList[1].toInt( &ok );
6516 if( !ok || anId < 1 )
6519 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6520 if( aPropertyValueList.size() != 2 )
6523 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6524 QString aMarkerTextureString = aPropertyValueList[1];
6525 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6526 if( aMarkerTextureStringList.size() != 3 )
6530 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6535 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6539 VTK::MarkerTexture aMarkerTexture;
6540 aMarkerTexture.push_back( aWidth );
6541 aMarkerTexture.push_back( aHeight );
6543 QString aMarkerTextureData = aMarkerTextureStringList[2];
6544 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6546 QChar aChar = aMarkerTextureData.at( i );
6547 if( aChar.isDigit() )
6548 aMarkerTexture.push_back( aChar.digitValue() );
6551 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6553 else if( aPropertyType == "ClippingPlane" )
6555 if( aPropertyNameList.size() != 3 )
6559 int aViewId = aPropertyNameList[1].toInt( &ok );
6560 if( !ok || aViewId < 0 )
6564 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6565 if( !ok || aClippingPlaneId < 0 )
6568 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6569 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6572 TPlaneData aPlaneData;
6573 aPlaneData.AbsoluteOrientation = false;
6574 aPlaneData.RelativeOrientation = 0;
6575 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6576 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6577 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6579 aPlaneData.Id = aClippingPlaneId;
6582 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6587 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6591 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6594 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6599 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6604 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6609 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6614 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6619 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6624 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6628 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6630 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6635 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6640 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6645 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6650 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6651 aPlaneDataList.push_back( aPlaneData );
6655 TPlaneInfoMap aPlaneInfoMap;
6657 std::vector<std::string> entries = ip->getEntries();
6659 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6661 // entry is a normal entry - it should be "decoded" (setting base address of component)
6662 QString entry (ip->decodeEntry(*entIt).c_str());
6664 // Check that the entry corresponds to a real object in the Study
6665 // as the object may be deleted or modified after the visual state is saved.
6666 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6667 if (!so) continue; //Skip the not existent entry
6669 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6670 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6672 std::vector<std::string>::iterator namesIt = paramNames.begin();
6673 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6675 // actors are stored in a map after displaying of them for
6676 // quicker access in the future: map < viewID to actor >
6677 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6679 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6681 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6682 // '_' is used as separator and should not be used in viewer type or parameter names.
6683 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6684 if (lst.size() != 3)
6687 QString viewerTypStr = lst[0];
6688 QString viewIndexStr = lst[1];
6689 QString paramNameStr = lst[2];
6692 int viewIndex = viewIndexStr.toUInt(&ok);
6693 if (!ok) // bad conversion of view index to integer
6697 if (viewerTypStr == SVTK_Viewer::Type())
6699 SMESH_Actor* aSmeshActor = 0;
6700 if (vtkActors.IsBound(viewIndex))
6701 aSmeshActor = vtkActors.Find(viewIndex);
6703 QList<SUIT_ViewManager*> lst;
6704 getApp()->viewManagers(viewerTypStr, lst);
6706 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6707 SUIT_ViewManager* vman = NULL;
6708 if (viewIndex >= 0 && viewIndex < lst.count())
6709 vman = lst.at(viewIndex);
6711 if (paramNameStr == "Visibility")
6713 if (!aSmeshActor && displayer() && vman)
6715 SUIT_ViewModel* vmodel = vman->getViewModel();
6716 // SVTK view model can be casted to SALOME_View
6717 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6719 // store displayed actor in a temporary map for quicker
6720 // access later when restoring other parameters
6721 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6722 vtkRenderer* Renderer = vtkView->getRenderer();
6723 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6724 vtkActorCollection* theActors = aCopy.GetActors();
6725 theActors->InitTraversal();
6726 bool isFound = false;
6727 vtkActor *ac = theActors->GetNextActor();
6728 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6729 if (ac->IsA("SMESH_Actor")) {
6730 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6731 if (aGeomAc->hasIO()) {
6732 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6733 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6735 vtkActors.Bind(viewIndex, aGeomAc);
6741 } // if (paramNameStr == "Visibility")
6744 // the rest properties "work" with SMESH_Actor
6747 QString val ((*valuesIt).c_str());
6750 if (paramNameStr == "Representation") {
6751 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6754 else if (paramNameStr == "IsShrunk") {
6756 if (!aSmeshActor->IsShrunk())
6757 aSmeshActor->SetShrink();
6760 if (aSmeshActor->IsShrunk())
6761 aSmeshActor->UnShrink();
6764 // Displayed entities
6765 else if (paramNameStr == "Entities") {
6766 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6767 int aEntityMode = SMESH_Actor::eAllEntity;
6768 for ( int i = 0; i < mode.count(); i+=2 ) {
6769 if ( i < mode.count()-1 ) {
6770 QString type = mode[i];
6771 bool val = mode[i+1].toInt();
6772 if ( type == "e" && !val )
6773 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6774 else if ( type == "f" && !val )
6775 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6776 else if ( type == "v" && !val )
6777 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6778 else if ( type == "0d" && !val )
6779 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6780 else if ( type == "b" && !val )
6781 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6784 aSmeshActor->SetEntityMode( aEntityMode );
6787 else if (paramNameStr == "Colors") {
6788 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6795 QColor outlineColor;
6796 QColor orientationColor;
6802 // below lines are required to get default values for delta coefficients
6803 // of backface color for faces and color of reversed volumes
6804 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6805 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6806 for ( int i = 0; i < colors.count(); i++ ) {
6807 QString type = colors[i];
6808 if ( type == "surface" ) {
6809 // face color is set by 3 values r:g:b, where
6810 // - r,g,b - is rgb color components
6811 if ( i+1 >= colors.count() ) break; // format error
6812 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6813 if ( i+2 >= colors.count() ) break; // format error
6814 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6815 if ( i+3 >= colors.count() ) break; // format error
6816 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6817 faceColor.setRgbF( r, g, b );
6820 else if ( type == "backsurface" ) {
6821 // backface color can be defined in several ways
6822 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6823 // - in latest versions, it is set as delta coefficient
6824 bool rgbOk = false, deltaOk;
6825 if ( i+1 >= colors.count() ) break; // format error
6826 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6827 int delta = colors[i+1].toInt( &deltaOk );
6829 if ( i+1 < colors.count() ) // index is shifted to 1
6830 g = colors[i+1].toDouble( &rgbOk );
6831 if ( rgbOk ) i++; // shift index
6832 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6833 b = colors[i+1].toDouble( &rgbOk );
6835 // - as currently there's no way to set directly backsurface color as it was before,
6836 // we ignore old dump where r,g,b triple was set
6837 // - also we check that delta parameter is set properly
6838 if ( !rgbOk && deltaOk )
6841 else if ( type == "volume" ) {
6842 // volume color is set by 4 values r:g:b:delta, where
6843 // - r,g,b - is a normal volume rgb color components
6844 // - delta - is a reversed volume color delta coefficient
6845 if ( i+1 >= colors.count() ) break; // format error
6846 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6847 if ( i+2 >= colors.count() ) break; // format error
6848 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6849 if ( i+3 >= colors.count() ) break; // format error
6850 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6851 if ( i+4 >= colors.count() ) break; // format error
6852 int delta = colors[i+4].toInt( &bOk );
6853 if ( !bOk ) break; // format error
6854 volumeColor.setRgbF( r, g, b );
6858 else if ( type == "edge" ) {
6859 // edge color is set by 3 values r:g:b, where
6860 // - r,g,b - is rgb color components
6861 if ( i+1 >= colors.count() ) break; // format error
6862 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6863 if ( i+2 >= colors.count() ) break; // format error
6864 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6865 if ( i+3 >= colors.count() ) break; // format error
6866 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6867 edgeColor.setRgbF( r, g, b );
6870 else if ( type == "node" ) {
6871 // node color is set by 3 values r:g:b, where
6872 // - r,g,b - is rgb color components
6873 if ( i+1 >= colors.count() ) break; // format error
6874 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6875 if ( i+2 >= colors.count() ) break; // format error
6876 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6877 if ( i+3 >= colors.count() ) break; // format error
6878 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6879 nodeColor.setRgbF( r, g, b );
6882 else if ( type == "elem0d" ) {
6883 // 0d element color is set by 3 values r:g:b, where
6884 // - r,g,b - is rgb color components
6885 if ( i+1 >= colors.count() ) break; // format error
6886 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6887 if ( i+2 >= colors.count() ) break; // format error
6888 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6889 if ( i+3 >= colors.count() ) break; // format error
6890 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6891 elem0dColor.setRgbF( r, g, b );
6894 else if ( type == "ball" ) {
6895 // ball color is set by 3 values r:g:b, where
6896 // - r,g,b - is rgb color components
6897 if ( i+1 >= colors.count() ) break; // format error
6898 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6899 if ( i+2 >= colors.count() ) break; // format error
6900 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6901 if ( i+3 >= colors.count() ) break; // format error
6902 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6903 ballColor.setRgbF( r, g, b );
6906 else if ( type == "outline" ) {
6907 // outline color is set by 3 values r:g:b, where
6908 // - r,g,b - is rgb color components
6909 if ( i+1 >= colors.count() ) break; // format error
6910 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6911 if ( i+2 >= colors.count() ) break; // format error
6912 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6913 if ( i+3 >= colors.count() ) break; // format error
6914 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6915 outlineColor.setRgbF( r, g, b );
6918 else if ( type == "orientation" ) {
6919 // orientation color is set by 3 values r:g:b, where
6920 // - r,g,b - is rgb color components
6921 if ( i+1 >= colors.count() ) break; // format error
6922 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6923 if ( i+2 >= colors.count() ) break; // format error
6924 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6925 if ( i+3 >= colors.count() ) break; // format error
6926 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6927 orientationColor.setRgbF( r, g, b );
6932 if ( nodeColor.isValid() )
6933 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6935 if ( edgeColor.isValid() )
6936 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6938 if ( faceColor.isValid() )
6939 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6941 if ( volumeColor.isValid() )
6942 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6943 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6944 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6946 if ( elem0dColor.isValid() )
6947 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6949 if ( ballColor.isValid() )
6950 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6952 if ( outlineColor.isValid() )
6953 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6954 // orientation color
6955 if ( orientationColor.isValid() )
6956 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6959 else if (paramNameStr == "Sizes") {
6960 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6963 int outlineWidth = -1;
6964 int elem0dSize = -1;
6965 //int ballSize = -1;
6966 double ballDiameter = -1.0;
6967 double ballScale = -1.0;
6968 double shrinkSize = -1;
6969 double orientationSize = -1;
6970 bool orientation3d = false;
6971 for ( int i = 0; i < sizes.count(); i++ ) {
6972 QString type = sizes[i];
6973 if ( type == "line" ) {
6974 // line (wireframe) width is given as single integer value
6975 if ( i+1 >= sizes.count() ) break; // format error
6976 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6980 if ( type == "outline" ) {
6981 // outline width is given as single integer value
6982 if ( i+1 >= sizes.count() ) break; // format error
6983 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6987 else if ( type == "elem0d" ) {
6988 // 0d element size is given as single integer value
6989 if ( i+1 >= sizes.count() ) break; // format error
6990 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6994 else if ( type == "ball" ) {
6995 // balls are specified by two values: size:scale, where
6996 // - size - is a integer value specifying size
6997 // - scale - is a double value specifying scale factor
6998 if ( i+1 >= sizes.count() ) break; // format error
6999 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7000 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7001 if ( i+2 >= sizes.count() ) break; // format error
7002 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
7008 else if ( type == "shrink" ) {
7009 // shrink factor is given as single floating point value
7010 if ( i+1 >= sizes.count() ) break; // format error
7011 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7015 else if ( type == "orientation" ) {
7016 // orientation vectors are specified by two values size:3d, where
7017 // - size - is a floating point value specifying scale factor
7018 // - 3d - is a boolean
7019 if ( i+1 >= sizes.count() ) break; // format error
7020 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7021 if ( i+2 >= sizes.count() ) break; // format error
7022 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7023 orientationSize = v1;
7024 orientation3d = (bool)v2;
7028 // line (wireframe) width
7029 if ( lineWidth > 0 )
7030 aSmeshActor->SetLineWidth( lineWidth );
7032 if ( outlineWidth > 0 )
7033 aSmeshActor->SetOutlineWidth( outlineWidth );
7034 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7035 aSmeshActor->SetOutlineWidth( lineWidth );
7037 if ( elem0dSize > 0 )
7038 aSmeshActor->Set0DSize( elem0dSize );
7040 /*if ( ballSize > 0 )
7041 aSmeshActor->SetBallSize( ballSize );*/
7043 if ( ballDiameter > 0 )
7044 aSmeshActor->SetBallSize( ballDiameter );
7046 if ( ballScale > 0.0 )
7047 aSmeshActor->SetBallScale( ballScale );
7049 if ( shrinkSize > 0 )
7050 aSmeshActor->SetShrinkFactor( shrinkSize );
7051 // orientation vectors
7052 if ( orientationSize > 0 ) {
7053 aSmeshActor->SetFacesOrientationScale( orientationSize );
7054 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7058 else if (paramNameStr == "PointMarker") {
7059 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7060 if( data.count() >= 2 ) {
7062 int aParam1 = data[1].toInt( &ok );
7064 if( data[0] == "std" && data.count() == 3 ) {
7065 int aParam2 = data[2].toInt( &ok );
7066 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7068 else if( data[0] == "custom" ) {
7069 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7070 if( markerIt != myMarkerMap.end() ) {
7071 VTK::MarkerData aMarkerData = markerIt->second;
7072 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7079 else if (paramNameStr == "Opacity") {
7080 aSmeshActor->SetOpacity(val.toFloat());
7083 else if (paramNameStr.startsWith("ClippingPlane")) {
7084 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7085 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7086 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7087 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7088 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7089 // new format - val looks like "Off" or "0" (plane id)
7090 // (note: in new format "Off" value is used only for consistency,
7091 // so it is processed together with values in old format)
7092 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7093 if( anIsOldFormat ) {
7094 if (paramNameStr == "ClippingPlane1" || val == "Off")
7095 aSmeshActor->RemoveAllClippingPlanes();
7097 QList<SUIT_ViewManager*> lst;
7098 getApp()->viewManagers(viewerTypStr, lst);
7099 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7100 if (viewIndex >= 0 && viewIndex < lst.count()) {
7101 SUIT_ViewManager* vman = lst.at(viewIndex);
7102 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7104 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7106 SMESH::TActorList anActorList;
7107 anActorList.push_back( aSmeshActor );
7108 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7109 aPlane->myViewWindow = vtkView;
7110 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7111 aPlane->PlaneMode = aMode;
7112 bool isOpenGLClipping = ( bool )vals[1].toInt();
7113 aPlane->IsOpenGLClipping = isOpenGLClipping;
7114 if ( aMode == SMESH::Absolute ) {
7115 aPlane->myAbsoluteOrientation = vals[2].toInt();
7116 aPlane->X = vals[3].toFloat();
7117 aPlane->Y = vals[4].toFloat();
7118 aPlane->Z = vals[5].toFloat();
7119 aPlane->Dx = vals[6].toFloat();
7120 aPlane->Dy = vals[7].toFloat();
7121 aPlane->Dz = vals[8].toFloat();
7123 else if ( aMode == SMESH::Relative ) {
7124 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7125 aPlane->myDistance = vals[3].toFloat();
7126 aPlane->myAngle[0] = vals[4].toFloat();
7127 aPlane->myAngle[1] = vals[5].toFloat();
7131 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7132 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7133 aClippingPlaneInfo.Plane = aPlane;
7134 aClippingPlaneInfo.ActorList = anActorList;
7135 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7143 int aPlaneId = val.toInt( &ok );
7144 if( ok && aPlaneId >= 0 ) {
7145 bool anIsDefinedPlane = false;
7146 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7147 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7148 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7149 TPlaneInfo& aPlaneInfo = *anIter;
7150 if( aPlaneInfo.PlaneId == aPlaneId ) {
7151 aPlaneInfo.ActorList.push_back( aSmeshActor );
7152 anIsDefinedPlane = true;
7156 if( !anIsDefinedPlane ) {
7157 TPlaneInfo aPlaneInfo;
7158 aPlaneInfo.PlaneId = aPlaneId;
7159 aPlaneInfo.ActorList.push_back( aSmeshActor );
7160 aPlaneInfo.ViewManager = vman;
7162 // to make the list sorted by plane id
7163 anIter = aPlaneInfoList.begin();
7164 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7165 const TPlaneInfo& aPlaneInfoRef = *anIter;
7166 if( aPlaneInfoRef.PlaneId > aPlaneId )
7169 aPlaneInfoList.insert( anIter, aPlaneInfo );
7174 } // if (aSmeshActor)
7175 } // other parameters than Visibility
7177 } // for names/parameters iterator
7178 } // for entries iterator
7180 // take into account planes with empty list of actors referred to them
7181 QList<SUIT_ViewManager*> aVMList;
7182 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7184 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7185 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7186 int aViewId = aPlaneDataIter->first;
7187 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7188 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7190 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7192 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7193 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7194 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7195 const TPlaneData& aPlaneData = *anIter2;
7196 int aPlaneId = aPlaneData.Id;
7198 bool anIsFound = false;
7199 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7200 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7201 const TPlaneInfo& aPlaneInfo = *anIter3;
7202 if( aPlaneInfo.PlaneId == aPlaneId ) {
7209 TPlaneInfo aPlaneInfo; // ActorList field is empty
7210 aPlaneInfo.PlaneId = aPlaneId;
7211 aPlaneInfo.ViewManager = aViewManager;
7213 // to make the list sorted by plane id
7214 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7215 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7216 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7217 if( aPlaneInfoRef.PlaneId > aPlaneId )
7220 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7226 // add clipping planes to actors according to the restored parameters
7227 // and update the clipping plane map
7228 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7229 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7230 int aViewId = anIter1->first;
7231 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7233 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7234 if( anIter2 == aPlaneDataMap.end() )
7236 const TPlaneDataList& aPlaneDataList = anIter2->second;
7238 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7239 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7240 const TPlaneInfo& aPlaneInfo = *anIter3;
7241 int aPlaneId = aPlaneInfo.PlaneId;
7242 const TActorList& anActorList = aPlaneInfo.ActorList;
7243 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7247 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7251 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7253 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7254 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7255 const TPlaneData& aPlaneData = *anIter4;
7256 if( aPlaneData.Id == aPlaneId ) {
7257 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7258 aPlane->myViewWindow = aViewWindow;
7259 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7260 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7261 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7262 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7263 aPlane->X = aPlaneData.X;
7264 aPlane->Y = aPlaneData.Y;
7265 aPlane->Z = aPlaneData.Z;
7266 aPlane->Dx = aPlaneData.Dx;
7267 aPlane->Dy = aPlaneData.Dy;
7268 aPlane->Dz = aPlaneData.Dz;
7270 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7271 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7272 aPlane->myDistance = aPlaneData.Distance;
7273 aPlane->myAngle[0] = aPlaneData.Angle[0];
7274 aPlane->myAngle[1] = aPlaneData.Angle[1];
7277 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7278 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7279 aClippingPlaneInfo.Plane = aPlane;
7280 aClippingPlaneInfo.ActorList = anActorList;
7281 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7292 // update all VTK views
7293 QList<SUIT_ViewManager*> lst;
7294 getApp()->viewManagers(lst);
7295 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7296 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7297 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7298 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7299 // set OpenGL clipping planes
7300 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7301 vtkActorCollection* anAllActors = aCopy.GetActors();
7302 anAllActors->InitTraversal();
7303 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7304 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7305 anActor->SetOpenGLClippingPlane();
7307 vtkView->getRenderer()->ResetCameraClippingRange();
7314 \brief Adds preferences for dfont of VTK viewer
7316 \param pIf group identifier
7317 \param param parameter
7318 \return identifier of preferences
7320 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7322 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7324 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7327 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7328 fam.append( tr( "SMESH_FONT_COURIER" ) );
7329 fam.append( tr( "SMESH_FONT_TIMES" ) );
7331 setPreferenceProperty( tfont, "fonts", fam );
7333 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7334 if ( needSize ) f = f | QtxFontEdit::Size;
7335 setPreferenceProperty( tfont, "features", f );
7341 \brief Actions after hypothesis edition
7342 Updates object browser after hypothesis edition
7344 void SMESHGUI::onHypothesisEdit( int result )
7347 SMESHGUI::Modified();
7348 updateObjBrowser( true );
7352 \brief Actions after choosing menu of control modes
7353 Updates control mode actions according to current selection
7355 void SMESHGUI::onUpdateControlActions()
7357 SALOME_ListIO selected;
7358 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7359 aSel->selectedObjects( selected );
7361 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7362 if ( selected.Extent() ) {
7363 if ( selected.First()->hasEntry() ) {
7364 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7365 aControl = anActor->GetControlMode();
7366 SALOME_ListIteratorOfListIO it(selected);
7367 for ( it.Next(); it.More(); it.Next() ) {
7368 Handle(SALOME_InteractiveObject) anIO = it.Value();
7369 if ( anIO->hasEntry() ) {
7370 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7371 if ( aControl != anActor->GetControlMode() ) {
7372 aControl = SMESH_Actor::eNone;
7382 int anAction = ActionToControl( aControl, true );
7384 action( anAction )->setChecked( true );
7386 QMenu* send = (QMenu*)sender();
7387 QList<QAction*> actions = send->actions();
7388 for ( int i = 0; i < actions.size(); i++ )
7389 actions[i]->setChecked( false );
7395 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7396 \param pview view being closed
7398 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7399 #ifndef DISABLE_PLOT2DVIEWER
7400 //Crear all Plot2d Viewers if need.
7401 SMESH::ClearPlot2Viewers(pview);
7403 EmitSignalCloseView();
7406 void SMESHGUI::message( const QString& msg )
7409 QStringList data = msg.split("/");
7410 if ( data.count() > 0 ) {
7411 if ( data.first() == "mesh_loading" ) {
7413 QString entry = data.count() > 1 ? data[1] : QString();
7414 if ( entry.isEmpty() )
7417 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7419 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7422 name = SMESH::fromUtf8(obj->GetName());
7423 if ( name.isEmpty() )
7426 if ( data.last() == "stop" )
7427 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7429 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7430 QApplication::processEvents();
7436 \brief Connects or disconnects signals about activating and cloning view on the module slots
7437 \param pview view which is connected/disconnected
7439 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7443 SUIT_ViewManager* viewMgr = pview->getViewManager();
7445 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7446 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7448 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7449 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7454 \brief Return \c true if object can be renamed
7456 bool SMESHGUI::renameAllowed( const QString& entry) const {
7457 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7461 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7465 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7470 if(appStudy->isComponent(entry) || obj->isReference())
7473 // check type to prevent renaming of inappropriate objects
7474 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7475 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7476 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7477 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7478 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7479 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7486 Rename object by entry.
7487 \param entry entry of the object
7488 \param name new name of the object
7489 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7491 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7493 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7497 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7502 _PTR(Study) aStudy = appStudy->studyDS();
7507 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7509 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7514 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7515 _PTR(GenericAttribute) anAttr;
7516 _PTR(AttributeName) aName;
7518 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7520 // check type to prevent renaming of inappropriate objects
7521 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7522 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7523 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7524 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7525 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7526 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7527 if ( !name.isEmpty() ) {
7528 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7530 // update name of group object and its actor
7531 Handle(SALOME_InteractiveObject) IObject =
7532 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7534 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7535 if( !aGroupObject->_is_nil() ) {
7536 aGroupObject->SetName( qUtf8Printable(name) );
7537 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7538 anActor->setName( qUtf8Printable(name) );
7548 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7550 static QList<QColor> colors;
7552 if ( colors.isEmpty() ) {
7554 for (int s = 0; s < 2 ; s++)
7556 for (int v = 100; v >= 40; v = v - 20)
7558 for (int h = 0; h < 359 ; h = h + 60)
7560 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7565 static int currentColor = randomize( colors.size() );
7567 SALOMEDS::Color color;
7568 color.R = (double)colors[currentColor].red() / 255.0;
7569 color.G = (double)colors[currentColor].green() / 255.0;
7570 color.B = (double)colors[currentColor].blue() / 255.0;
7572 currentColor = (currentColor+1) % colors.count();