1 // Copyright (C) 2007-2020 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_AdaptDlg.h"
34 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
35 #include "SMESHGUI_AddMeshElementDlg.h"
36 #include "SMESHGUI_AddQuadraticElementDlg.h"
37 #include "SMESHGUI_BuildCompoundDlg.h"
38 #include "SMESHGUI_ClippingDlg.h"
39 #include "SMESHGUI_ComputeDlg.h"
40 #include "SMESHGUI_ConvToQuadOp.h"
41 #include "SMESHGUI_CopyMeshDlg.h"
42 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
43 #include "SMESHGUI_DeleteGroupDlg.h"
44 #include "SMESHGUI_DisplayEntitiesDlg.h"
45 #include "SMESHGUI_Displayer.h"
46 #include "SMESHGUI_DuplicateNodesDlg.h"
47 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
48 #include "SMESHGUI_ExtrusionDlg.h"
49 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
50 #include "SMESHGUI_FieldSelectorWdg.h"
51 #include "SMESHGUI_FileInfoDlg.h"
52 #include "SMESHGUI_FileValidator.h"
53 #include "SMESHGUI_FilterDlg.h"
54 #include "SMESHGUI_FilterLibraryDlg.h"
55 #include "SMESHGUI_FilterUtils.h"
56 #include "SMESHGUI_FindElemByPointDlg.h"
57 #include "SMESHGUI_GEOMGenUtils.h"
58 #include "SMESHGUI_GroupDlg.h"
59 #include "SMESHGUI_GroupOnShapeDlg.h"
60 #include "SMESHGUI_GroupOpDlg.h"
61 #include "SMESHGUI_GroupUtils.h"
62 #include "SMESHGUI_Hypotheses.h"
63 #include "SMESHGUI_HypothesesUtils.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 <SALOMEDSClient_ClientFactory.hxx>
172 #include <SALOMEDSClient_IParameters.hxx>
173 #include <SALOMEDSClient_SComponent.hxx>
174 #include <SALOMEDSClient_StudyBuilder.hxx>
175 #include <SALOMEDS_Study.hxx>
176 #include <SALOMEDS_SObject.hxx>
177 #include "utilities.h"
178 #include <SALOME_LifeCycleCORBA.hxx>
181 #include <Standard_ErrorHandler.hxx>
182 #include <NCollection_DataMap.hxx>
183 #include <NCollection_DoubleMap.hxx>
185 #include <Basics_Utils.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 case SMESHOp::OpMGAdapt:
3049 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3050 SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3053 case SMESHOp::OpSplitBiQuadratic:
3054 case SMESHOp::OpConvertMeshToQuadratic:
3055 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3056 case SMESHOp::OpReorientFaces:
3057 case SMESHOp::OpCreateGeometryGroup:
3059 if ( warnOnGeomModif() )
3060 break; // action forbidden as geometry modified
3061 startOperation( theCommandID );
3064 case SMESHOp::OpCreateGroup:
3068 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3072 if(isStudyLocked()) break;
3073 if ( warnOnGeomModif() )
3074 break; // action forbidden as geometry modified
3075 EmitSignalDeactivateDialog();
3076 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3078 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3079 SALOME_ListIO selected;
3081 aSel->selectedObjects( selected );
3083 int nbSel = selected.Extent();
3085 // check if mesh is selected
3086 aMesh = SMESH::GetMeshByIO( selected.First() );
3088 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3093 case SMESHOp::OpConstructGroup:
3097 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3101 if(isStudyLocked()) break;
3102 if ( warnOnGeomModif() )
3103 break; // action forbidden as geometry modified
3104 EmitSignalDeactivateDialog();
3106 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3107 SALOME_ListIO selected;
3109 aSel->selectedObjects( selected );
3111 int nbSel = selected.Extent();
3113 // check if submesh is selected
3114 Handle(SALOME_InteractiveObject) IObject = selected.First();
3115 if (IObject->hasEntry()) {
3116 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3118 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3119 if (!aSubMesh->_is_nil()) {
3121 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3122 // get submesh elements list by types
3123 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3124 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3125 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3126 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3127 // create group for each type o elements
3128 QString aName = IObject->getName();
3129 QStringList anEntryList;
3130 if (aNodes->length() > 0) {
3131 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3132 aGroup->Add(aNodes.inout());
3133 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3134 anEntryList.append( aSObject->GetID().c_str() );
3136 if (aEdges->length() > 0) {
3137 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3138 aGroup->Add(aEdges.inout());
3139 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3140 anEntryList.append( aSObject->GetID().c_str() );
3142 if (aFaces->length() > 0) {
3143 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3144 aGroup->Add(aFaces.inout());
3145 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3146 anEntryList.append( aSObject->GetID().c_str() );
3148 if (aVolumes->length() > 0) {
3149 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3150 aGroup->Add(aVolumes.inout());
3151 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3152 anEntryList.append( aSObject->GetID().c_str() );
3155 anApp->browseObjects( anEntryList );
3157 catch(const SALOME::SALOME_Exception & S_ex){
3158 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3165 SUIT_MessageBox::warning(desktop(),
3166 tr("SMESH_WRN_WARNING"),
3167 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3172 case SMESHOp::OpEditGroup:
3176 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3180 if(isStudyLocked()) break;
3181 if ( warnOnGeomModif() )
3182 break; // action forbidden as geometry modified
3183 EmitSignalDeactivateDialog();
3185 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3186 SALOME_ListIO selected;
3188 aSel->selectedObjects( selected );
3190 SALOME_ListIteratorOfListIO It (selected);
3191 int nbSelectedGroups = 0;
3192 for ( ; It.More(); It.Next() )
3194 SMESH::SMESH_GroupBase_var aGroup =
3195 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3196 if (!aGroup->_is_nil()) {
3198 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3202 if (nbSelectedGroups == 0)
3204 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3210 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3212 if(isStudyLocked()) break;
3213 if (myState == 800) {
3214 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3215 if (aDlg) aDlg->onAdd();
3220 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3222 if(isStudyLocked()) break;
3223 if (myState == 800) {
3224 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3225 if (aDlg) aDlg->onRemove();
3230 case SMESHOp::OpEditGeomGroupAsGroup:
3234 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3238 if(isStudyLocked()) break;
3239 EmitSignalDeactivateDialog();
3241 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3242 SALOME_ListIO selected;
3244 aSel->selectedObjects( selected );
3246 SALOME_ListIteratorOfListIO It (selected);
3247 for ( ; It.More(); It.Next() )
3249 SMESH::SMESH_GroupOnGeom_var aGroup =
3250 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3251 if (!aGroup->_is_nil()) {
3252 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3257 SMESH::SMESH_GroupOnFilter_var aGroup =
3258 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3259 if (!aGroup->_is_nil()) {
3260 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3268 case SMESHOp::OpUnionGroups:
3269 case SMESHOp::OpIntersectGroups:
3270 case SMESHOp::OpCutGroups:
3274 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3278 if ( isStudyLocked() )
3280 if ( warnOnGeomModif() )
3281 break; // action forbidden as geometry modified
3283 EmitSignalDeactivateDialog();
3285 SMESHGUI_GroupOpDlg* aDlg = 0;
3286 if ( theCommandID == SMESHOp::OpUnionGroups )
3287 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3288 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3289 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3291 aDlg = new SMESHGUI_CutGroupsDlg( this );
3298 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3300 if ( isStudyLocked() )
3302 if ( warnOnGeomModif() )
3303 break; // action forbidden as geometry modified
3305 EmitSignalDeactivateDialog();
3306 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3312 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3314 if ( isStudyLocked() )
3316 if ( warnOnGeomModif() )
3317 break; // action forbidden as geometry modified
3319 EmitSignalDeactivateDialog();
3320 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3326 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3330 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3334 if ( isStudyLocked() )
3337 EmitSignalDeactivateDialog();
3339 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3343 case SMESHOp::OpMeshInformation:
3344 case SMESHOp::OpWhatIs:
3346 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3347 EmitSignalDeactivateDialog();
3348 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3349 SALOME_ListIO selected;
3351 aSel->selectedObjects( selected );
3353 if ( selected.Extent() > 1 ) { // a dlg for each IO
3354 SALOME_ListIteratorOfListIO It( selected );
3355 for ( ; It.More(); It.Next() ) {
3356 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3357 dlg->showInfo( It.Value() );
3362 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3368 case SMESHOp::OpFindElementByPoint:
3370 startOperation( theCommandID );
3374 case SMESHOp::OpEditHypothesis:
3376 if(isStudyLocked()) break;
3377 if ( warnOnGeomModif() )
3378 break; // action forbidden as geometry modified
3380 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3381 SALOME_ListIO selected;
3383 aSel->selectedObjects( selected );
3385 int nbSel = selected.Extent();
3388 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3389 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3391 if ( !aHypothesis->_is_nil() )
3393 SMESHGUI_GenericHypothesisCreator* aCreator =
3394 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3397 // set geometry of mesh and sub-mesh to aCreator
3398 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3399 if ( selected.Extent() == 1 )
3401 QString subGeomID, meshGeomID;
3402 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3403 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3405 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3406 aCreator->setShapeEntry( subGeomID );
3407 aCreator->setMainShapeEntry( meshGeomID );
3411 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3421 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3423 if(isStudyLocked()) break;
3424 if ( warnOnGeomModif() )
3425 break; // action forbidden as geometry modified
3426 SUIT_OverrideCursor wc;
3428 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3429 SALOME_ListIO selected;
3431 aSel->selectedObjects( selected, QString::null, false );
3433 SALOME_ListIteratorOfListIO It(selected);
3434 for (int i = 0; It.More(); It.Next(), i++) {
3435 Handle(SALOME_InteractiveObject) IObject = It.Value();
3436 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3439 aSel->setSelectedObjects( l1 );
3444 case SMESHOp::OpElem0D:
3445 case SMESHOp::OpBall:
3446 case SMESHOp::OpEdge:
3447 case SMESHOp::OpTriangle:
3448 case SMESHOp::OpQuadrangle:
3449 case SMESHOp::OpPolygon:
3450 case SMESHOp::OpTetrahedron:
3451 case SMESHOp::OpHexahedron:
3452 case SMESHOp::OpPentahedron:
3453 case SMESHOp::OpPyramid:
3454 case SMESHOp::OpHexagonalPrism:
3456 if(isStudyLocked()) break;
3457 if ( warnOnGeomModif() )
3458 break; // action forbidden as geometry modified
3460 EmitSignalDeactivateDialog();
3461 SMDSAbs_EntityType type = SMDSEntity_Edge;
3462 switch (theCommandID) {
3463 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3464 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3465 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3466 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3467 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3468 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3469 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3470 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3471 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3472 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3475 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3478 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3482 case SMESHOp::OpPolyhedron:
3484 if(isStudyLocked()) break;
3485 if ( warnOnGeomModif() )
3486 break; // action forbidden as geometry modified
3488 EmitSignalDeactivateDialog();
3489 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3492 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpQuadraticEdge:
3497 case SMESHOp::OpQuadraticTriangle:
3498 case SMESHOp::OpBiQuadraticTriangle:
3499 case SMESHOp::OpQuadraticQuadrangle:
3500 case SMESHOp::OpBiQuadraticQuadrangle:
3501 case SMESHOp::OpQuadraticPolygon:
3502 case SMESHOp::OpQuadraticTetrahedron:
3503 case SMESHOp::OpQuadraticPyramid:
3504 case SMESHOp::OpQuadraticPentahedron:
3505 case SMESHOp::OpBiQuadraticPentahedron:
3506 case SMESHOp::OpQuadraticHexahedron:
3507 case SMESHOp::OpTriQuadraticHexahedron:
3509 if(isStudyLocked()) break;
3510 if ( warnOnGeomModif() )
3511 break; // action forbidden as geometry modified
3513 EmitSignalDeactivateDialog();
3514 SMDSAbs_EntityType type = SMDSEntity_Last;
3516 switch (theCommandID) {
3517 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3518 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3519 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3520 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3521 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3522 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3523 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3524 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3525 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3526 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3527 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3528 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3531 if ( type != SMDSEntity_Last )
3532 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3535 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3536 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3540 case SMESHOp::OpRemoveNodes:
3542 if(isStudyLocked()) break;
3543 if ( warnOnGeomModif() )
3544 break; // action forbidden as geometry modified
3546 EmitSignalDeactivateDialog();
3547 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3550 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3555 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3557 if(isStudyLocked()) break;
3558 if ( warnOnGeomModif() )
3559 break; // action forbidden as geometry modified
3561 EmitSignalDeactivateDialog();
3562 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3566 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3567 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3571 case SMESHOp::OpClearMesh: {
3573 if(isStudyLocked()) break;
3574 if ( warnOnGeomModif() )
3575 break; // action forbidden as geometry modified
3577 SALOME_ListIO selected;
3578 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3579 aSel->selectedObjects( selected );
3581 SUIT_OverrideCursor wc;
3582 SALOME_ListIteratorOfListIO It (selected);
3583 for ( ; It.More(); It.Next() )
3585 Handle(SALOME_InteractiveObject) IOS = It.Value();
3586 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3587 if ( aMesh->_is_nil()) continue;
3590 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3591 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3592 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3593 // hide groups and submeshes
3594 _PTR(ChildIterator) anIter =
3595 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3596 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3598 _PTR(SObject) so = anIter->Value();
3599 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3602 catch (const SALOME::SALOME_Exception& S_ex){
3604 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3608 SMESH::UpdateView();
3612 case SMESHOp::OpRemoveOrphanNodes:
3614 if(isStudyLocked()) break;
3615 if ( warnOnGeomModif() )
3616 break; // action forbidden as geometry modified
3617 SALOME_ListIO selected;
3618 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3619 aSel->selectedObjects( selected );
3620 if ( selected.Extent() == 1 ) {
3621 Handle(SALOME_InteractiveObject) anIO = selected.First();
3622 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3623 if ( !aMesh->_is_nil() ) {
3624 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3625 tr( "SMESH_WARNING" ),
3626 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3627 SUIT_MessageBox::Yes |
3628 SUIT_MessageBox::No,
3629 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3632 SUIT_OverrideCursor wc;
3633 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3634 int removed = aMeshEditor->RemoveOrphanNodes();
3635 SUIT_MessageBox::information(SMESHGUI::desktop(),
3636 tr("SMESH_INFORMATION"),
3637 tr("NB_NODES_REMOVED").arg(removed));
3638 if ( removed > 0 ) {
3639 SMESH::UpdateView();
3640 SMESHGUI::Modified();
3643 catch (const SALOME::SALOME_Exception& S_ex) {
3644 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3653 case SMESHOp::OpRenumberingNodes:
3655 if(isStudyLocked()) break;
3656 if ( warnOnGeomModif() )
3657 break; // action forbidden as geometry modified
3659 EmitSignalDeactivateDialog();
3660 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3664 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3665 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3669 case SMESHOp::OpRenumberingElements:
3671 if(isStudyLocked()) break;
3672 if ( warnOnGeomModif() )
3673 break; // action forbidden as geometry modified
3675 EmitSignalDeactivateDialog();
3676 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3680 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3681 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3685 case SMESHOp::OpTranslation:
3687 if(isStudyLocked()) break;
3688 if ( warnOnGeomModif() )
3689 break; // action forbidden as geometry modified
3691 EmitSignalDeactivateDialog();
3692 ( new SMESHGUI_TranslationDlg( this ) )->show();
3695 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3696 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3700 case SMESHOp::OpRotation:
3702 if(isStudyLocked()) break;
3703 if ( warnOnGeomModif() )
3704 break; // action forbidden as geometry modified
3706 EmitSignalDeactivateDialog();
3707 ( new SMESHGUI_RotationDlg( this ) )->show();
3710 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3711 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3715 case SMESHOp::OpSymmetry:
3717 if(isStudyLocked()) break;
3718 if ( warnOnGeomModif() )
3719 break; // action forbidden as geometry modified
3721 EmitSignalDeactivateDialog();
3722 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3725 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3726 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3730 case SMESHOp::OpScale:
3732 if(isStudyLocked()) break;
3733 if ( warnOnGeomModif() )
3734 break; // action forbidden as geometry modified
3736 EmitSignalDeactivateDialog();
3737 ( new SMESHGUI_ScaleDlg( this ) )->show();
3740 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3741 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3746 case SMESHOp::OpOffset:
3748 if(isStudyLocked()) break;
3749 if ( warnOnGeomModif() )
3750 break; // action forbidden as geometry modified
3752 EmitSignalDeactivateDialog();
3753 ( new SMESHGUI_OffsetDlg( this ) )->show();
3756 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3757 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3762 case SMESHOp::OpSewing:
3764 if(isStudyLocked()) break;
3765 if ( warnOnGeomModif() )
3766 break; // action forbidden as geometry modified
3768 EmitSignalDeactivateDialog();
3769 ( new SMESHGUI_SewingDlg( this ) )->show();
3772 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3773 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3777 case SMESHOp::OpMergeNodes:
3779 if(isStudyLocked()) break;
3780 if ( warnOnGeomModif() )
3781 break; // action forbidden as geometry modified
3783 EmitSignalDeactivateDialog();
3784 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3787 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3788 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3792 case SMESHOp::OpMergeElements:
3794 if (isStudyLocked()) break;
3795 if ( warnOnGeomModif() )
3796 break; // action forbidden as geometry modified
3798 EmitSignalDeactivateDialog();
3799 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3801 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3802 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3807 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3808 if ( warnOnGeomModif() )
3809 break; // action forbidden as geometry modified
3810 startOperation( SMESHOp::OpMoveNode );
3813 case SMESHOp::OpDuplicateNodes:
3815 if(isStudyLocked()) break;
3816 if ( warnOnGeomModif() )
3817 break; // action forbidden as geometry modified
3819 EmitSignalDeactivateDialog();
3820 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3823 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3824 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3829 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3830 if ( warnOnGeomModif() )
3831 break; // action forbidden as geometry modified
3832 startOperation( SMESHOp::OpElem0DOnElemNodes );
3835 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3837 static QList<int> aTypes;
3838 if ( aTypes.isEmpty() )
3840 aTypes.append( SMESH::NODE );
3841 aTypes.append( SMESH::EDGE );
3842 aTypes.append( SMESH::FACE );
3843 aTypes.append( SMESH::VOLUME );
3845 if (!myFilterLibraryDlg)
3846 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3847 else if (myFilterLibraryDlg->isHidden())
3848 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3849 myFilterLibraryDlg->raise();
3853 case SMESHOp::OpFreeNode:
3854 case SMESHOp::OpEqualNode:
3855 case SMESHOp::OpNodeConnectivityNb:
3856 case SMESHOp::OpFreeEdge:
3857 case SMESHOp::OpFreeBorder:
3858 case SMESHOp::OpLength:
3859 case SMESHOp::OpConnection:
3860 case SMESHOp::OpEqualEdge:
3861 case SMESHOp::OpFreeFace:
3862 case SMESHOp::OpBareBorderFace:
3863 case SMESHOp::OpOverConstrainedFace:
3864 case SMESHOp::OpLength2D:
3865 case SMESHOp::OpDeflection2D:
3866 case SMESHOp::OpConnection2D:
3867 case SMESHOp::OpArea:
3868 case SMESHOp::OpTaper:
3869 case SMESHOp::OpAspectRatio:
3870 case SMESHOp::OpMinimumAngle:
3871 case SMESHOp::OpWarpingAngle:
3872 case SMESHOp::OpSkew:
3873 case SMESHOp::OpMaxElementLength2D:
3874 case SMESHOp::OpEqualFace:
3875 case SMESHOp::OpAspectRatio3D:
3876 case SMESHOp::OpVolume:
3877 case SMESHOp::OpMaxElementLength3D:
3878 case SMESHOp::OpBareBorderVolume:
3879 case SMESHOp::OpOverConstrainedVolume:
3880 case SMESHOp::OpEqualVolume:
3883 LightApp_SelectionMgr* mgr = selectionMgr();
3884 SALOME_ListIO selected; mgr->selectedObjects( selected );
3886 if( !selected.IsEmpty() ) {
3887 SUIT_OverrideCursor wc;
3888 ::Control( theCommandID );
3891 SUIT_MessageBox::warning(desktop(),
3892 tr( "SMESH_WRN_WARNING" ),
3893 tr( "SMESH_BAD_SELECTION" ) );
3897 SUIT_MessageBox::warning(desktop(),
3898 tr( "SMESH_WRN_WARNING" ),
3899 tr( "NOT_A_VTK_VIEWER" ) );
3902 case SMESHOp::OpOverallMeshQuality:
3903 OverallMeshQuality();
3905 case SMESHOp::OpNumberingNodes:
3907 SUIT_OverrideCursor wc;
3908 LightApp_SelectionMgr* mgr = selectionMgr();
3909 SALOME_ListIO selected; mgr->selectedObjects( selected );
3911 SALOME_ListIteratorOfListIO it(selected);
3912 for( ; it.More(); it.Next()) {
3913 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3914 if(anIObject->hasEntry()) {
3915 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3916 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3922 case SMESHOp::OpNumberingElements:
3924 SUIT_OverrideCursor wc;
3925 LightApp_SelectionMgr* mgr = selectionMgr();
3926 SALOME_ListIO selected; mgr->selectedObjects( selected );
3928 SALOME_ListIteratorOfListIO it(selected);
3929 for( ; it.More(); it.Next()) {
3930 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3931 if(anIObject->hasEntry())
3932 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3933 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3938 case SMESHOp::OpPropertiesLength:
3939 case SMESHOp::OpPropertiesArea:
3940 case SMESHOp::OpPropertiesVolume:
3941 case SMESHOp::OpMinimumDistance:
3942 case SMESHOp::OpBoundingBox:
3943 case SMESHOp::OpAngle:
3945 int page = SMESHGUI_MeasureDlg::MinDistance;
3946 if ( theCommandID == SMESHOp::OpBoundingBox )
3947 page = SMESHGUI_MeasureDlg::BoundingBox;
3948 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3949 page = SMESHGUI_MeasureDlg::Length;
3950 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3951 page = SMESHGUI_MeasureDlg::Area;
3952 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3953 page = SMESHGUI_MeasureDlg::Volume;
3954 else if ( theCommandID == SMESHOp::OpAngle )
3955 page = SMESHGUI_MeasureDlg::Angle;
3957 EmitSignalDeactivateDialog();
3958 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3962 case SMESHOp::OpSortChild:
3965 case SMESHOp::OpBreakLink:
3966 ::breakShaperLink();
3971 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3972 //updateObjBrowser();
3976 //=============================================================================
3980 //=============================================================================
3981 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3986 //=============================================================================
3990 //=============================================================================
3991 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3996 //=============================================================================
4000 //=============================================================================
4001 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4006 //=============================================================================
4007 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4008 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4010 //=============================================================================
4011 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4012 SUIT_ViewWindow* wnd )
4014 if(theIO->hasEntry()){
4015 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4016 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4020 //=======================================================================
4021 // function : createSMESHAction
4023 //=======================================================================
4024 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4025 const int key, const bool toggle, const QString& shortcutAction )
4028 QWidget* parent = application()->desktop();
4029 SUIT_ResourceMgr* resMgr = resourceMgr();
4031 if ( !icon_id.isEmpty() )
4032 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4034 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4035 if ( !pix.isNull() )
4036 icon = QIcon( pix );
4038 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4039 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4040 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4042 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4043 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4046 //=======================================================================
4047 // function : createPopupItem
4049 //=======================================================================
4050 void SMESHGUI::createPopupItem( const int id,
4051 const QString& clients,
4052 const QString& types,
4053 const QString& theRule,
4056 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4057 popupMgr()->insert( action( id ), pId, 0 );
4059 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4060 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4061 QString rule = "(%1) and (%2) and (%3)";
4062 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4063 if( clients.isEmpty() )
4064 rule = rule.arg( QString( "true" ) );
4066 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4067 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4070 bool cont = myRules.contains( id );
4072 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4074 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4075 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4078 //=======================================================================
4079 // function : initialize
4081 //=======================================================================
4082 void SMESHGUI::initialize( CAM_Application* app )
4084 SalomeApp_Module::initialize( app );
4086 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4088 /* Automatic Update flag */
4089 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4091 // ----- create actions --------------
4093 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4094 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4095 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4096 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4098 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4100 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4101 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4102 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4103 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4104 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4106 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4108 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4109 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4111 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4112 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4113 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4114 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4116 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4118 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4119 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4120 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4121 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4122 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4123 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4125 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4127 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4128 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4129 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4130 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4131 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4132 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4133 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4134 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4135 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4136 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4137 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4138 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4139 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4140 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4141 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4142 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4143 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4144 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4145 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4146 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4147 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4148 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4149 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4150 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4151 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4152 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4153 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4154 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4155 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4156 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4157 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4158 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4159 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4160 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4161 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4162 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4164 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4165 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4166 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4167 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4168 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4169 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4170 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4171 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4172 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4173 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4174 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4175 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4176 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4177 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4178 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4179 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4180 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4181 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4182 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4183 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4184 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4185 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4186 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4187 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4188 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4189 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4190 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4191 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4192 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4194 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4195 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4196 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4197 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4198 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4199 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4200 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4201 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4202 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4203 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4204 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4205 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4206 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4207 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4208 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4209 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4210 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4211 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4212 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4213 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4214 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4215 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4216 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4217 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4218 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4219 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4221 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4222 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4223 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4224 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4226 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4227 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4229 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4230 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4231 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4232 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4233 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4234 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4235 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4236 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4237 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4238 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4239 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4240 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4241 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4242 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4243 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4244 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4245 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4246 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4247 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4248 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4249 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4250 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4251 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4252 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4253 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4255 createSMESHAction( SMESHOp::OpReset, "RESET" );
4256 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4257 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4258 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4259 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4260 #ifndef DISABLE_PLOT2DVIEWER
4261 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4263 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4264 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4265 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4266 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4267 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4268 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4269 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4270 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4271 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4272 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4273 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4274 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4275 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4277 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4278 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4280 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4281 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4282 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4283 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4284 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4285 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4286 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4287 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4288 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4290 // Adaptation - begin
4291 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4294 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4295 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4296 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4297 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4298 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4299 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4301 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4302 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4303 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4305 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4307 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4309 QList<int> aCtrlActions;
4310 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4311 << SMESHOp::OpNodeConnectivityNb // node controls
4312 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4313 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4314 << SMESHOp::OpDeflection2D
4315 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4316 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4317 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4318 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4319 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4320 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4321 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4322 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4323 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4324 aCtrlGroup->setExclusive( true );
4325 for( int i = 0; i < aCtrlActions.size(); i++ )
4326 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4328 // ----- create menu --------------
4329 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4330 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4331 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4332 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4333 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4334 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4335 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4336 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4337 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4339 createMenu( separator(), fileId );
4341 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4342 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4343 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4344 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4345 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4346 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4347 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4348 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4349 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4350 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4351 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4352 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4353 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4355 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4356 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4357 createMenu( SMESHOp::OpImportMED, importId, -1 );
4358 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4360 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4362 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4363 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4364 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4365 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4366 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4367 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4369 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4371 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4372 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4373 createMenu( separator(), fileId, 10 );
4375 createMenu( SMESHOp::OpDelete, editId, -1 );
4377 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4379 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4380 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4381 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4382 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4383 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4384 createMenu( separator(), meshId, -1 );
4385 createMenu( SMESHOp::OpCompute, meshId, -1 );
4386 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4387 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4388 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4389 createMenu( separator(), meshId, -1 );
4390 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4391 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4392 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4393 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4394 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4395 createMenu( separator(), meshId, -1 );
4396 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4397 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4398 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4399 createMenu( separator(), meshId, -1 );
4400 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4401 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4402 createMenu( separator(), meshId, -1 );
4403 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4404 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4405 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4406 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4407 createMenu( separator(), meshId, -1 );
4409 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4410 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4411 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4412 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4413 createMenu( SMESHOp::OpLength, edgeId, -1 );
4414 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4415 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4416 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4417 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4418 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4419 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4420 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4421 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4422 createMenu( SMESHOp::OpArea, faceId, -1 );
4423 createMenu( SMESHOp::OpTaper, faceId, -1 );
4424 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4425 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4426 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4427 createMenu( SMESHOp::OpSkew, faceId, -1 );
4428 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4429 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4430 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4431 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4432 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4433 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4434 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4435 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4436 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4437 createMenu( separator(), ctrlId, -1 );
4438 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4439 createMenu( separator(), ctrlId, -1 );
4440 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4442 createMenu( SMESHOp::OpNode, addId, -1 );
4443 createMenu( SMESHOp::OpElem0D, addId, -1 );
4444 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4445 createMenu( SMESHOp::OpBall, addId, -1 );
4446 createMenu( SMESHOp::OpEdge, addId, -1 );
4447 createMenu( SMESHOp::OpTriangle, addId, -1 );
4448 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4449 createMenu( SMESHOp::OpPolygon, addId, -1 );
4450 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4451 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4452 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4453 createMenu( SMESHOp::OpPyramid, addId, -1 );
4454 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4455 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4456 createMenu( separator(), addId, -1 );
4457 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4458 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4459 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4460 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4461 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4462 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4463 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4464 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4465 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4466 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4467 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4468 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4470 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4471 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4472 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4473 createMenu( separator(), removeId, -1 );
4474 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4475 createMenu( separator(), removeId, -1 );
4476 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4478 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4479 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4481 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4482 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4483 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4484 createMenu( SMESHOp::OpRotation, transfId, -1 );
4485 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4486 createMenu( SMESHOp::OpScale, transfId, -1 );
4487 createMenu( SMESHOp::OpOffset, transfId, -1 );
4488 createMenu( SMESHOp::OpSewing, transfId, -1 );
4489 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4491 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4492 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4493 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4494 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4495 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4496 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4497 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4498 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4499 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4500 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4501 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4502 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4503 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4504 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4505 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4506 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4508 // Adaptation - begin
4509 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4512 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4513 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4514 createMenu( SMESHOp::OpAngle, measureId, -1 );
4515 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4516 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4517 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4518 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4520 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4521 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4522 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4523 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4525 // ----- create toolbars --------------
4526 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4527 createTool( SMESHOp::OpCreateMesh, meshTb );
4528 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4529 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4530 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4531 createTool( SMESHOp::OpCopyMesh, meshTb );
4532 createTool( separator(), meshTb );
4533 createTool( SMESHOp::OpCompute, meshTb );
4534 createTool( SMESHOp::OpPreCompute, meshTb );
4535 createTool( SMESHOp::OpEvaluate, meshTb );
4536 createTool( SMESHOp::OpMeshOrder, meshTb );
4538 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4539 createTool( SMESHOp::OpMeshInformation, infoTb );
4540 //createTool( SMESHOp::OpStdInfo, meshTb );
4541 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4542 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4544 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4545 createTool( SMESHOp::OpCreateGroup, groupTb );
4546 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4547 createTool( SMESHOp::OpConstructGroup, groupTb );
4548 createTool( SMESHOp::OpEditGroup, groupTb );
4550 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4551 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4552 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4553 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4555 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4556 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4557 createTool( SMESHOp::OpLength, ctrl1dTb );
4558 createTool( SMESHOp::OpConnection, ctrl1dTb );
4559 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4561 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4562 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4563 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4564 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4565 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4566 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4567 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4568 createTool( SMESHOp::OpArea, ctrl2dTb );
4569 createTool( SMESHOp::OpTaper, ctrl2dTb );
4570 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4571 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4572 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4573 createTool( SMESHOp::OpSkew, ctrl2dTb );
4574 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4575 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4576 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4578 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4579 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4580 createTool( SMESHOp::OpVolume, ctrl3dTb );
4581 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4582 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4583 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4584 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4586 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4587 createTool( SMESHOp::OpNode, addElemTb );
4588 createTool( SMESHOp::OpElem0D, addElemTb );
4589 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4590 createTool( SMESHOp::OpBall, addElemTb );
4591 createTool( SMESHOp::OpEdge, addElemTb );
4592 createTool( SMESHOp::OpTriangle, addElemTb );
4593 createTool( SMESHOp::OpQuadrangle, addElemTb );
4594 createTool( SMESHOp::OpPolygon, addElemTb );
4595 createTool( SMESHOp::OpTetrahedron, addElemTb );
4596 createTool( SMESHOp::OpHexahedron, addElemTb );
4597 createTool( SMESHOp::OpPentahedron, addElemTb );
4598 createTool( SMESHOp::OpPyramid, addElemTb );
4599 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4600 createTool( SMESHOp::OpPolyhedron, addElemTb );
4602 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4603 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4604 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4605 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4606 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4607 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4608 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4609 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4610 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4611 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4612 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4613 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4614 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4616 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4617 createTool( SMESHOp::OpRemoveNodes, remTb );
4618 createTool( SMESHOp::OpRemoveElements, remTb );
4619 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4620 createTool( SMESHOp::OpClearMesh, remTb );
4622 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4623 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4624 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4626 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4627 createTool( SMESHOp::OpMergeNodes, transformTb );
4628 createTool( SMESHOp::OpMergeElements, transformTb );
4629 createTool( SMESHOp::OpTranslation, transformTb );
4630 createTool( SMESHOp::OpRotation, transformTb );
4631 createTool( SMESHOp::OpSymmetry, transformTb );
4632 createTool( SMESHOp::OpScale, transformTb );
4633 createTool( SMESHOp::OpOffset, transformTb );
4634 createTool( SMESHOp::OpSewing, transformTb );
4635 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4637 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4638 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4639 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4640 createTool( SMESHOp::OpExtrusion, modifyTb );
4641 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4642 createTool( SMESHOp::OpRevolution, modifyTb );
4643 createTool( SMESHOp::OpOrientation, modifyTb );
4644 createTool( SMESHOp::OpReorientFaces, modifyTb );
4645 createTool( SMESHOp::OpMoveNode, modifyTb );
4646 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4647 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4648 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4649 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4650 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4651 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4652 createTool( SMESHOp::OpSmoothing, modifyTb );
4653 createTool( SMESHOp::OpPatternMapping, modifyTb );
4655 // Adaptation - begin
4656 int adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ) ;
4657 createTool( SMESHOp::OpMGAdapt, adaptTb );
4660 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4661 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4663 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4664 createTool( SMESHOp::OpUpdate, dispModeTb );
4666 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4667 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4671 OB = "'ObjectBrowser'",
4672 View = "'" + SVTK_Viewer::Type() + "'",
4674 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4675 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4676 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4677 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4678 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4679 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4680 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4681 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4682 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4683 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4684 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4685 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4687 mesh_part = mesh + " " + subMesh + " " + group,
4688 mesh_group = mesh + " " + group,
4689 mesh_submesh = mesh + " " + subMesh,
4690 hyp_alg = hypo + " " + algo;
4692 // popup for object browser
4694 isInvisible("not( isVisible )"),
4695 isEmpty("numberOfNodes = 0"),
4696 isNotEmpty("numberOfNodes <> 0"),
4698 // has nodes, edges, etc in VISIBLE! actor
4699 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4700 hasElems("(count( elemTypes ) > 0)"),
4701 hasDifferentElems("(count( elemTypes ) > 1)"),
4702 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4703 hasBalls("({'BallElem'} in elemTypes)"),
4704 hasElems0d("({'Elem0d'} in elemTypes)"),
4705 hasEdges("({'Edge'} in elemTypes)"),
4706 hasFaces("({'Face'} in elemTypes)"),
4707 hasVolumes("({'Volume'} in elemTypes)"),
4708 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4710 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4711 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4712 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4713 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4714 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4715 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4717 popupMgr()->insert( separator(), -1, 0 );
4718 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4719 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4720 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4721 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4722 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4723 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4724 popupMgr()->insert( separator(), -1, 0 );
4725 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4726 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4727 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4728 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4729 popupMgr()->insert( separator(), -1, 0 );
4730 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4731 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4732 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4733 popupMgr()->insert( separator(), -1, 0 );
4734 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4735 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4736 popupMgr()->insert( separator(), -1, 0 );
4737 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4738 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4739 popupMgr()->insert( separator(), -1, 0 );
4741 // Adaptation - begin
4742 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4745 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4746 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4747 QString only_one_2D = only_one_non_empty + " && dim>1";
4749 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4750 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4751 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4752 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4753 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4755 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4757 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4758 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4759 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4761 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4762 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4763 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4764 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4766 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4768 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4769 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4770 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4771 popupMgr()->insert( separator(), -1, 0 );
4773 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4774 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4775 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4778 createPopupItem( SMESHOp::OpEditGroup, View, group );
4779 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4780 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4782 popupMgr()->insert( separator(), -1, 0 );
4783 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4784 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4785 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4786 popupMgr()->insert( separator(), -1, 0 );
4788 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4789 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4790 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4791 popupMgr()->insert( separator(), -1, 0 );
4793 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4794 QString aType = QString( "%1type in {%2}" ).arg( lc );
4795 aType = aType.arg( mesh_part );
4796 QString aMeshInVTK = aClient + "&&" + aType;
4798 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4799 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4800 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4802 //-------------------------------------------------
4804 //-------------------------------------------------
4805 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4807 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4808 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4809 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4811 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4812 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4813 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4815 popupMgr()->insert( separator(), -1, -1 );
4817 //-------------------------------------------------
4819 //-------------------------------------------------
4820 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4822 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4823 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4824 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4826 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4827 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4828 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4830 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4831 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4832 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4834 popupMgr()->insert( separator(), anId, -1 );
4836 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4837 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4838 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4840 //-------------------------------------------------
4842 //-------------------------------------------------
4843 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4845 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4847 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4848 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4849 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4851 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4853 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4855 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4856 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4857 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4859 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4860 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4861 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4863 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4864 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4865 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4867 popupMgr()->insert( separator(), anId, -1 );
4869 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4870 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4872 popupMgr()->insert( separator(), anId, -1 );
4874 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4875 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4878 //-------------------------------------------------
4879 // Representation of the 2D Quadratic elements
4880 //-------------------------------------------------
4881 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4882 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4883 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4884 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4886 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4887 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4888 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4890 //-------------------------------------------------
4891 // Orientation of faces
4892 //-------------------------------------------------
4893 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4894 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4895 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4897 //-------------------------------------------------
4899 //-------------------------------------------------
4900 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4901 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4903 //-------------------------------------------------
4905 //-------------------------------------------------
4906 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4907 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4909 //-------------------------------------------------
4911 //-------------------------------------------------
4913 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4914 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4915 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4916 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4918 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4920 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4921 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4923 popupMgr()->insert( separator(), anId, -1 );
4925 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4927 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4928 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4929 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4931 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4932 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4933 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4935 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4936 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4937 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4939 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4941 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4942 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4943 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4945 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4946 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4947 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4949 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4950 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4951 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4952 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4953 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4954 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4956 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4958 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4959 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4960 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4962 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4963 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4964 QtxPopupMgr::VisibleRule );
4965 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4967 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4968 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4969 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4971 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4972 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4973 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4975 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4976 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4977 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4979 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4980 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4983 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4984 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4985 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4987 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4988 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4989 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4991 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4992 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4993 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4995 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4996 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4997 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4999 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5000 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5001 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5003 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5004 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5005 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5007 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5008 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5009 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5011 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5012 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5013 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5015 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5016 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5017 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5019 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5021 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5022 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5023 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5025 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5026 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5027 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5029 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5030 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5031 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5033 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5034 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5035 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5037 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5038 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5039 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5041 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5042 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5043 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5045 popupMgr()->insert( separator(), anId, -1 );
5047 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5048 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5049 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5050 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5051 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5053 popupMgr()->insert( separator(), anId, -1 );
5055 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5057 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5058 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5060 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5061 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5062 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5064 #ifndef DISABLE_PLOT2DVIEWER
5065 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5066 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5069 //-------------------------------------------------
5071 //-------------------------------------------------
5072 popupMgr()->insert( separator(), -1, -1 );
5073 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5074 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5075 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5076 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5078 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5079 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5081 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5082 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5084 popupMgr()->insert( separator(), -1, -1 );
5086 //-------------------------------------------------
5088 //-------------------------------------------------
5089 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5090 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5092 popupMgr()->insert( separator(), -1, -1 );
5094 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5095 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5096 popupMgr()->insert( separator(), -1, -1 );
5098 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5099 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5101 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5102 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5104 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5105 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5108 //================================================================================
5110 * \brief Return true if SMESH or GEOM objects are selected.
5111 * Is called form LightApp_Module::activateModule() which clear selection if
5112 * not isSelectionCompatible()
5114 //================================================================================
5116 bool SMESHGUI::isSelectionCompatible()
5118 bool isCompatible = true;
5119 SALOME_ListIO selected;
5120 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5121 Sel->selectedObjects( selected );
5123 SALOME_ListIteratorOfListIO It( selected );
5124 for ( ; isCompatible && It.More(); It.Next())
5126 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5127 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5128 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5130 return isCompatible;
5134 bool SMESHGUI::reusableOperation( const int id )
5136 // compute, evaluate and precompute are not reusable operations
5137 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5142 QString wrap(const QString& text, const QString& tag)
5143 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5146 bool SMESHGUI::activateModule( SUIT_Study* study )
5148 bool res = SalomeApp_Module::activateModule( study );
5150 setMenuShown( true );
5151 setToolShown( true );
5153 // Fill in Help Panel
5154 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5155 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5157 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5160 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5161 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5162 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5163 lab = lab + tr("INFO_REFINE") + ":";
5164 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5165 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5166 lab = lab + wrap(items.join(""), "ul");
5169 app->infoPanel()->addLabel(lab, gb);
5171 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5172 items << wrap("UNV", "li")
5173 << wrap("MED", "li")
5174 << wrap("STL", "li")
5175 << wrap("CGNS", "li")
5176 << wrap("SAUV", "li")
5177 << wrap("GMF", "li");
5178 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5181 app->infoPanel()->addLabel(lab, gb);
5183 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5184 lab = tr("INFO_DISPLAY") + "<br/>";
5185 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5186 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5187 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5188 << wrap("...", "li");
5189 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5191 lab = lab + tr("INFO_CLIPPING");
5193 app->infoPanel()->addLabel(lab, gb);
5196 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5197 PyGILState_STATE gstate = PyGILState_Ensure();
5198 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5199 if ( !pluginsmanager ) {
5203 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5208 PyGILState_Release(gstate);
5209 // end of SMESH plugins loading
5211 // Reset actions accelerator keys
5212 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5214 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5215 GetSMESHGen()->UpdateStudy();
5217 // get all view currently opened in the study and connect their signals to
5218 // the corresponding slots of the class.
5219 SUIT_Desktop* aDesk = study->application()->desktop();
5221 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5222 SUIT_ViewWindow* wnd;
5223 foreach ( wnd, wndList )
5227 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5228 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5234 Py_XDECREF(pluginsmanager);
5238 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5240 setMenuShown( false );
5241 setToolShown( false );
5243 EmitSignalCloseAllDialogs();
5245 // Unset actions accelerator keys
5246 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5248 return SalomeApp_Module::deactivateModule( study );
5251 void SMESHGUI::studyClosed( SUIT_Study* s )
5255 SMESH::RemoveVisuData();
5256 SalomeApp_Module::studyClosed( s );
5259 void SMESHGUI::OnGUIEvent()
5261 const QObject* obj = sender();
5262 if ( !obj || !obj->inherits( "QAction" ) )
5264 int id = actionId((QAction*)obj);
5269 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5271 if ( CORBA::is_nil( myComponentSMESH ) )
5273 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5274 return aGUI.myComponentSMESH;
5276 return myComponentSMESH;
5279 QString SMESHGUI::engineIOR() const
5281 CORBA::ORB_var anORB = getApp()->orb();
5282 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5283 return QString( anIOR.in() );
5286 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5288 SalomeApp_Module::contextMenuPopup( client, menu, title );
5290 selectionMgr()->selectedObjects( lst );
5291 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5292 Handle(SALOME_InteractiveObject) io = lst.First();
5293 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5294 _PTR(Study) study = appStudy->studyDS();
5295 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5297 QString aName = SMESH::fromUtf8( obj->GetName());
5298 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5299 aName.remove(( aName.length() - 1 ), 1 );
5305 LightApp_Selection* SMESHGUI::createSelection() const
5307 return new SMESHGUI_Selection();
5310 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5312 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5313 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5314 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5315 #ifndef DISABLE_PYCONSOLE
5316 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5320 void SMESHGUI::viewManagers( QStringList& list ) const
5322 list.append( SVTK_Viewer::Type() );
5325 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5327 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5328 SMESH::UpdateSelectionProp( this );
5330 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5331 for(int i = 0; i < aViews.count() ; i++){
5332 SUIT_ViewWindow *sf = aViews[i];
5335 EmitSignalActivatedViewManager();
5339 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5341 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5342 myClippingPlaneInfoMap.erase( theViewManager );
5345 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5347 theActor->AddObserver( SMESH::DeleteActorEvent,
5348 myEventCallbackCommand.GetPointer(),
5352 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5353 unsigned long theEvent,
5354 void* theClientData,
5355 void* /*theCallData*/ )
5357 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5358 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5359 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5360 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5361 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5362 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5363 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5364 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5365 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5366 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5367 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5368 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5369 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5370 if( anActor == *anIter3 ) {
5371 anActorList.erase( anIter3 );
5382 void SMESHGUI::createPreferences()
5384 // General tab ------------------------------------------------------------------------
5385 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5387 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5388 setPreferenceProperty( autoUpdate, "columns", 2 );
5389 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5390 setPreferenceProperty( lim, "min", 0 );
5391 setPreferenceProperty( lim, "max", 100000000 );
5392 setPreferenceProperty( lim, "step", 1000 );
5393 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5394 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5396 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5397 setPreferenceProperty( dispgroup, "columns", 2 );
5399 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5401 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5403 modes.append( tr("MEN_WIRE") );
5404 modes.append( tr("MEN_SHADE") );
5405 modes.append( tr("MEN_NODES") );
5406 modes.append( tr("MEN_SHRINK") );
5407 QList<QVariant> indices;
5408 indices.append( 0 );
5409 indices.append( 1 );
5410 indices.append( 2 );
5411 indices.append( 3 );
5412 setPreferenceProperty( dispmode, "strings", modes );
5413 setPreferenceProperty( dispmode, "indexes", indices );
5415 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5416 setPreferenceProperty( arcgroup, "columns", 2 );
5417 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5418 QStringList quadraticModes;
5419 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5420 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5422 indices.append( 0 );
5423 indices.append( 1 );
5424 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5425 setPreferenceProperty( quadraticmode, "indexes", indices );
5427 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5428 "SMESH", "max_angle" );
5429 setPreferenceProperty( maxAngle, "min", 1 );
5430 setPreferenceProperty( maxAngle, "max", 90 );
5432 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5433 setPreferenceProperty( qaGroup, "columns", 2 );
5434 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5435 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5436 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5437 setPreferenceProperty( prec, "min", 0 );
5438 setPreferenceProperty( prec, "max", 100 );
5439 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5440 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5441 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5442 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5443 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5446 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5447 setPreferenceProperty( cinc, "min", 0 );
5448 setPreferenceProperty( cinc, "max", 5 );
5451 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5452 setPreferenceProperty( exportgroup, "columns", 2 );
5453 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5454 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5455 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5456 setPreferenceProperty( zTol, "precision", 10 );
5457 setPreferenceProperty( zTol, "min", 0.0000000001 );
5458 setPreferenceProperty( zTol, "max", 1000000.0 );
5459 setPreferenceProperty( zTol, "step", 1. );
5460 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5462 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5463 setPreferenceProperty( computeGroup, "columns", 2 );
5464 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5466 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5467 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5468 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5470 indices.append( 0 );
5471 indices.append( 1 );
5472 indices.append( 2 );
5473 setPreferenceProperty( notifyMode, "strings", modes );
5474 setPreferenceProperty( notifyMode, "indexes", indices );
5476 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5477 setPreferenceProperty( infoGroup, "columns", 2 );
5478 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5480 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5481 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5483 indices.append( 0 );
5484 indices.append( 1 );
5485 setPreferenceProperty( elemInfo, "strings", modes );
5486 setPreferenceProperty( elemInfo, "indexes", indices );
5487 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5488 setPreferenceProperty( nodesLim, "min", 0 );
5489 setPreferenceProperty( nodesLim, "max", 10000000 );
5490 setPreferenceProperty( nodesLim, "step", 10000 );
5491 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5492 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5493 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5494 setPreferenceProperty( ctrlLim, "min", 0 );
5495 setPreferenceProperty( ctrlLim, "max", 10000000 );
5496 setPreferenceProperty( ctrlLim, "step", 1000 );
5497 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5498 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5499 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5500 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5501 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5503 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5504 setPreferenceProperty( segGroup, "columns", 2 );
5505 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5506 "SMESH", "segmentation" );
5507 setPreferenceProperty( segLen, "min", 1 );
5508 setPreferenceProperty( segLen, "max", 10000000 );
5509 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5510 "SMESH", "nb_segments_per_edge" );
5511 setPreferenceProperty( nbSeg, "min", 1 );
5512 setPreferenceProperty( nbSeg, "max", 10000000 );
5513 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5515 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5516 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5517 "SMESH", "forget_mesh_on_hyp_modif" );
5520 // Quantities with individual precision settings
5521 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5522 setPreferenceProperty( precGroup, "columns", 2 );
5524 const int nbQuantities = 6;
5525 int precs[nbQuantities], ii = 0;
5526 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5527 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5528 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5529 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5530 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5531 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5532 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5533 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5534 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5535 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5536 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5537 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5539 // Set property for precision value for spinboxes
5540 for ( ii = 0; ii < nbQuantities; ii++ ){
5541 setPreferenceProperty( precs[ii], "min", -14 );
5542 setPreferenceProperty( precs[ii], "max", 14 );
5543 setPreferenceProperty( precs[ii], "precision", 2 );
5546 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5547 setPreferenceProperty( previewGroup, "columns", 2 );
5548 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5549 setPreferenceProperty( chunkSize, "min", 1 );
5550 setPreferenceProperty( chunkSize, "max", 1000 );
5551 setPreferenceProperty( chunkSize, "step", 50 );
5553 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5554 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5556 // Mesh tab ------------------------------------------------------------------------
5557 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5558 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5559 setPreferenceProperty( nodeGroup, "columns", 3 );
5561 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5563 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5565 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5566 QList<QVariant> aMarkerTypeIndicesList;
5567 QList<QVariant> aMarkerTypeIconsList;
5568 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5569 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5570 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5571 aMarkerTypeIndicesList << i;
5572 aMarkerTypeIconsList << pixmap;
5574 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5575 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5577 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5579 QList<QVariant> aMarkerScaleIndicesList;
5580 QStringList aMarkerScaleValuesList;
5581 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5582 aMarkerScaleIndicesList << i;
5583 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5584 aMarkerScaleValuesList << QString::number( i );
5586 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5587 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5589 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5590 //setPreferenceProperty( elemGroup, "columns", 2 );
5592 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5593 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5594 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5595 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5596 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5597 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5598 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5599 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5600 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5603 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5604 setPreferenceProperty( grpGroup, "columns", 2 );
5606 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5607 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5609 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5610 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5611 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5612 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5613 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5614 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5615 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5616 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5617 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5618 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5619 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5620 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5621 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5622 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5624 setPreferenceProperty( size0d, "min", 1 );
5625 setPreferenceProperty( size0d, "max", 10 );
5627 // setPreferenceProperty( ballSize, "min", 1 );
5628 // setPreferenceProperty( ballSize, "max", 10 );
5630 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5631 setPreferenceProperty( ballDiameter, "max", 1e9 );
5632 setPreferenceProperty( ballDiameter, "step", 0.1 );
5634 setPreferenceProperty( ballScale, "min", 1e-2 );
5635 setPreferenceProperty( ballScale, "max", 1e7 );
5636 setPreferenceProperty( ballScale, "step", 0.5 );
5638 setPreferenceProperty( elemW, "min", 1 );
5639 setPreferenceProperty( elemW, "max", 5 );
5641 setPreferenceProperty( outW, "min", 1 );
5642 setPreferenceProperty( outW, "max", 5 );
5644 setPreferenceProperty( shrink, "min", 0 );
5645 setPreferenceProperty( shrink, "max", 100 );
5647 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5648 setPreferenceProperty( numGroup, "columns", 2 );
5650 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5651 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5653 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5654 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5656 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5657 setPreferenceProperty( orientGroup, "columns", 1 );
5659 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5660 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5662 setPreferenceProperty( orientScale, "min", 0.05 );
5663 setPreferenceProperty( orientScale, "max", 0.5 );
5664 setPreferenceProperty( orientScale, "step", 0.05 );
5666 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5668 // Selection tab ------------------------------------------------------------------------
5669 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5671 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5672 setPreferenceProperty( selGroup, "columns", 2 );
5674 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5675 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5677 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5678 setPreferenceProperty( preGroup, "columns", 2 );
5680 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5682 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5683 setPreferenceProperty( precSelGroup, "columns", 2 );
5685 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5686 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5687 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5689 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5690 setPreferenceProperty( sinc, "min", 0 );
5691 setPreferenceProperty( sinc, "max", 5 );
5693 // Scalar Bar tab ------------------------------------------------------------------------
5694 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5695 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5696 setPreferenceProperty( fontGr, "columns", 2 );
5698 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5699 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5701 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5702 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5704 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5705 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5707 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5708 setPreferenceProperty( numcol, "min", 2 );
5709 setPreferenceProperty( numcol, "max", 256 );
5711 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5712 setPreferenceProperty( numlab, "min", 2 );
5713 setPreferenceProperty( numlab, "max", 65 );
5715 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5716 setPreferenceProperty( orientGr, "columns", 2 );
5717 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5718 QStringList orients;
5719 orients.append( tr( "SMESH_VERTICAL" ) );
5720 orients.append( tr( "SMESH_HORIZONTAL" ) );
5721 indices.clear(); indices.append( 0 ); indices.append( 1 );
5722 setPreferenceProperty( orient, "strings", orients );
5723 setPreferenceProperty( orient, "indexes", indices );
5725 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5726 setPreferenceProperty( posVSizeGr, "columns", 2 );
5727 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5728 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5729 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5730 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5731 setPreferenceProperty( xv, "step", 0.1 );
5732 setPreferenceProperty( xv, "min", 0.0 );
5733 setPreferenceProperty( xv, "max", 1.0 );
5734 setPreferenceProperty( yv, "step", 0.1 );
5735 setPreferenceProperty( yv, "min", 0.0 );
5736 setPreferenceProperty( yv, "max", 1.0 );
5737 setPreferenceProperty( wv, "step", 0.1 );
5738 setPreferenceProperty( wv, "min", 0.0 );
5739 setPreferenceProperty( wv, "max", 1.0 );
5740 setPreferenceProperty( hv, "min", 0.0 );
5741 setPreferenceProperty( hv, "max", 1.0 );
5742 setPreferenceProperty( hv, "step", 0.1 );
5744 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5745 setPreferenceProperty( posHSizeGr, "columns", 2 );
5746 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5747 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5748 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5749 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5750 setPreferenceProperty( xv, "min", 0.0 );
5751 setPreferenceProperty( xv, "max", 1.0 );
5752 setPreferenceProperty( xv, "step", 0.1 );
5753 setPreferenceProperty( xh, "min", 0.0 );
5754 setPreferenceProperty( xh, "max", 1.0 );
5755 setPreferenceProperty( xh, "step", 0.1 );
5756 setPreferenceProperty( yh, "min", 0.0 );
5757 setPreferenceProperty( yh, "max", 1.0 );
5758 setPreferenceProperty( yh, "step", 0.1 );
5759 setPreferenceProperty( wh, "min", 0.0 );
5760 setPreferenceProperty( wh, "max", 1.0 );
5761 setPreferenceProperty( wh, "step", 0.1 );
5762 setPreferenceProperty( hh, "min", 0.0 );
5763 setPreferenceProperty( hh, "max", 1.0 );
5764 setPreferenceProperty( hh, "step", 0.1 );
5766 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5767 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5768 setPreferenceProperty( distributionGr, "columns", 3 );
5770 types.append( tr( "SMESH_MONOCOLOR" ) );
5771 types.append( tr( "SMESH_MULTICOLOR" ) );
5772 indices.clear(); indices.append( 0 ); indices.append( 1 );
5773 setPreferenceProperty( coloringType, "strings", types );
5774 setPreferenceProperty( coloringType, "indexes", indices );
5775 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5777 // Adaptation - begin
5778 // Adaptation tab ------------------------------------------------------------------------
5779 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5782 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5783 setPreferenceProperty( bloc, "columns", 1 );
5784 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5785 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5786 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5787 QStringList aListOfSizeMap;
5788 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5789 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5790 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5791 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5792 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5793 QStringList aListOfTimeStep;
5794 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5795 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5796 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5797 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5802 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5804 if ( sect=="SMESH" ) {
5805 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5806 float aTol = 1.00000009999999;
5807 std::string aWarning;
5808 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5810 if ( name == "selection_object_color" ||
5811 name == "selection_element_color" ||
5812 name == "highlight_color" ||
5813 name == "selection_precision_node" ||
5814 name == "selection_precision_element" ||
5815 name == "selection_precision_object" ||
5816 name == "selection_increment")
5818 SMESH::UpdateSelectionProp( this );
5820 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5822 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5823 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5824 if ( sbX1+sbW > aTol ) {
5825 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5828 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5829 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5832 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5834 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5835 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5836 if ( sbY1 + sbH > aTol ) {
5837 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5838 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5839 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5842 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5844 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5845 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5846 if ( sbX1 + sbW > aTol ) {
5847 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5850 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5851 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5854 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5856 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5857 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5858 if ( sbY1 + sbH > aTol ) {
5859 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5862 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5863 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5866 else if ( name == "segmentation" )
5868 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5869 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5871 else if ( name == "nb_segments_per_edge" )
5873 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5874 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5876 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5878 QString val = aResourceMgr->stringValue( "SMESH", name );
5879 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5881 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5883 SMESH::UpdateFontProp( this );
5885 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5887 SMESH::UpdateFontProp( this );
5890 if ( aWarning.size() != 0 ) {
5891 aWarning += "The default values are applied instead.";
5892 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5893 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5894 QObject::tr(aWarning.c_str()));
5899 //================================================================================
5901 * \brief Update something in accordance with update flags
5902 * \param theFlags - update flags
5904 * Update viewer or/and object browser etc. in accordance with update flags ( see
5905 * LightApp_UpdateFlags enumeration ).
5907 //================================================================================
5908 void SMESHGUI::update( const int flags )
5910 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5911 SMESH::UpdateView();
5913 SalomeApp_Module::update( flags );
5916 //================================================================================
5918 * \brief Set default selection mode
5920 * SLOT called when operation committed. Sets default selection mode
5922 //================================================================================
5923 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5925 SVTK_ViewWindow* vtkWnd =
5926 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5928 vtkWnd->SetSelectionMode( ActorSelection );
5931 //================================================================================
5933 * \brief Set default selection mode
5935 * SLOT called when operation aborted. Sets default selection mode
5937 //================================================================================
5938 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5940 SVTK_ViewWindow* vtkWnd =
5941 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5943 vtkWnd->SetSelectionMode( ActorSelection );
5946 //================================================================================
5948 * \brief Creates operation with given identifier
5949 * \param id - identifier of operation to be started
5950 * \return Pointer on created operation or NULL if operation is not created
5952 * Virtual method redefined from the base class creates operation with given id.
5953 * It is called called automatically from startOperation method of base class.
5955 //================================================================================
5956 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5958 LightApp_Operation* op = 0;
5959 // to do : create operation here
5962 case SMESHOp::OpSplitBiQuadratic:
5963 op = new SMESHGUI_SplitBiQuadOp();
5965 case SMESHOp::OpConvertMeshToQuadratic:
5966 op = new SMESHGUI_ConvToQuadOp();
5968 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5969 op = new SMESHGUI_Make2DFrom3DOp();
5971 case SMESHOp::OpReorientFaces:
5972 op = new SMESHGUI_ReorientFacesOp();
5974 case SMESHOp::OpCreateMesh:
5975 op = new SMESHGUI_MeshOp( true, true );
5977 case SMESHOp::OpCreateSubMesh:
5978 op = new SMESHGUI_MeshOp( true, false );
5980 case SMESHOp::OpEditMeshOrSubMesh:
5981 case SMESHOp::OpEditMesh:
5982 case SMESHOp::OpEditSubMesh:
5983 op = new SMESHGUI_MeshOp( false );
5985 case SMESHOp::OpCompute:
5986 case SMESHOp::OpComputeSubMesh:
5987 op = new SMESHGUI_ComputeOp();
5989 case SMESHOp::OpShowErrors:
5990 op = new SMESHGUI_ShowErrorsOp();
5992 case SMESHOp::OpPreCompute:
5993 op = new SMESHGUI_PrecomputeOp();
5995 case SMESHOp::OpEvaluate:
5996 op = new SMESHGUI_EvaluateOp();
5998 case SMESHOp::OpMeshOrder:
5999 op = new SMESHGUI_MeshOrderOp();
6001 case SMESHOp::OpCreateGeometryGroup:
6002 op = new SMESHGUI_GroupOnShapeOp();
6004 case SMESHOp::OpFindElementByPoint:
6005 op = new SMESHGUI_FindElemByPointOp();
6007 case SMESHOp::OpMoveNode: // Make mesh pass through point
6008 op = new SMESHGUI_MakeNodeAtPointOp();
6010 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6011 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6013 // Adaptation - begin
6014 case SMESHOp::OpMGAdapt:
6022 op = SalomeApp_Module::createOperation( id );
6026 //================================================================================
6028 * \brief Stops current operations and starts a given one
6029 * \param id - The id of the operation to start
6031 //================================================================================
6033 void SMESHGUI::switchToOperation(int id)
6035 activeStudy()->abortAllOperations();
6036 startOperation( id );
6039 LightApp_Displayer* SMESHGUI::displayer()
6042 myDisplayer = new SMESHGUI_Displayer( getApp() );
6046 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6049 int aTolerance = 64;
6050 int anIterations = 0;
6056 if( anIterations % aPeriod == 0 )
6059 if( aTolerance < 1 )
6063 aHue = (int)( 360.0 * rand() / RAND_MAX );
6066 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6067 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6068 for( ; it != itEnd; ++it )
6070 SALOMEDS::Color anAutoColor = *it;
6071 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6074 aQColor.getHsv( &h, &s, &v );
6075 if( abs( h - aHue ) < aTolerance )
6087 aColor.setHsv( aHue, 255, 255 );
6089 SALOMEDS::Color aSColor;
6090 aSColor.R = aColor.redF();
6091 aSColor.G = aColor.greenF();
6092 aSColor.B = aColor.blueF();
6097 const char* gSeparator = "_"; // character used to separate parameter names
6098 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6099 const char* gPathSep = "|"; // character used to separate paths
6102 * \brief Store visual parameters
6104 * This method is called just before the study document is saved.
6105 * Store visual parameters in AttributeParameter attribute(s)
6107 void SMESHGUI::storeVisualParameters (int savePoint)
6110 Kernel_Utils::Localizer loc;
6112 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6113 if (!appStudy || !appStudy->studyDS())
6115 _PTR(Study) studyDS = appStudy->studyDS();
6117 // componentName is used for encoding of entries when storing them in IParameters
6118 std::string componentName = myComponentSMESH->ComponentDataType();
6119 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6120 //if (!aSComponent) return;
6123 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6124 componentName.c_str(),
6126 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6128 // store custom markers
6129 if( !myMarkerMap.empty() )
6131 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6132 for( ; anIter != myMarkerMap.end(); anIter++ )
6134 int anId = anIter->first;
6135 VTK::MarkerData aMarkerData = anIter->second;
6136 std::string aMarkerFileName = aMarkerData.first;
6137 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6138 if( aMarkerTexture.size() < 3 )
6139 continue; // should contain at least width, height and the first value
6141 QString aPropertyName( "texture" );
6142 aPropertyName += gSeparator;
6143 aPropertyName += QString::number( anId );
6145 QString aPropertyValue = aMarkerFileName.c_str();
6146 aPropertyValue += gPathSep;
6148 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6149 ushort aWidth = *aTextureIter++;
6150 ushort aHeight = *aTextureIter++;
6151 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6152 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6153 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6154 aPropertyValue += QString::number( *aTextureIter );
6156 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6160 // viewers counters are used for storing view_numbers in IParameters
6163 // main cycle to store parameters of displayed objects
6164 QList<SUIT_ViewManager*> lst;
6165 QList<SUIT_ViewManager*>::Iterator it;
6166 getApp()->viewManagers(lst);
6167 for (it = lst.begin(); it != lst.end(); it++)
6169 SUIT_ViewManager* vman = *it;
6170 QString vType = vman->getType();
6172 // saving VTK actors properties
6173 if (vType == SVTK_Viewer::Type())
6175 // store the clipping planes attached to the view manager
6176 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6177 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6178 if( anIter != myClippingPlaneInfoMap.end() )
6179 aClippingPlaneInfoList = anIter->second;
6181 if( !aClippingPlaneInfoList.empty() ) {
6182 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6183 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6185 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6186 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6188 QString aPropertyName( "ClippingPlane" );
6189 aPropertyName += gSeparator;
6190 aPropertyName += QString::number( vtkViewers );
6191 aPropertyName += gSeparator;
6192 aPropertyName += QString::number( anId );
6194 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6195 aPropertyValue += gDigitsSep;
6196 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6197 aPropertyValue += gDigitsSep;
6198 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6199 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6200 aPropertyValue += gDigitsSep;
6201 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6202 aPropertyValue += gDigitsSep;
6203 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6204 aPropertyValue += gDigitsSep;
6205 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6206 aPropertyValue += gDigitsSep;
6207 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6208 aPropertyValue += gDigitsSep;
6209 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6210 aPropertyValue += gDigitsSep;
6211 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6213 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6214 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6215 aPropertyValue += gDigitsSep;
6216 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6217 aPropertyValue += gDigitsSep;
6218 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6219 aPropertyValue += gDigitsSep;
6220 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6223 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6227 QVector<SUIT_ViewWindow*> views = vman->getViews();
6228 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6230 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6232 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6233 vtkActorCollection* allActors = aCopy.GetActors();
6234 allActors->InitTraversal();
6235 while (vtkActor* actor = allActors->GetNextActor())
6237 if (actor->GetVisibility()) // store only visible actors
6239 SMESH_Actor* aSmeshActor = 0;
6240 if (actor->IsA("SMESH_Actor"))
6241 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6242 if (aSmeshActor && aSmeshActor->hasIO())
6244 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6247 // entry is "encoded" = it does NOT contain component address,
6248 // since it is a subject to change on next component loading
6249 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6251 std::string param, vtkParam = vType.toLatin1().data();
6252 vtkParam += gSeparator;
6253 vtkParam += QString::number(vtkViewers).toLatin1().data();
6254 vtkParam += gSeparator;
6257 param = vtkParam + "Visibility";
6258 ip->setParameter(entry, param, "On");
6261 param = vtkParam + "Representation";
6262 ip->setParameter(entry, param, QString::number
6263 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6266 param = vtkParam + "IsShrunk";
6267 ip->setParameter(entry, param, QString::number
6268 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6270 // Displayed entities
6271 unsigned int aMode = aSmeshActor->GetEntityMode();
6272 bool isE = aMode & SMESH_Actor::eEdges;
6273 bool isF = aMode & SMESH_Actor::eFaces;
6274 bool isV = aMode & SMESH_Actor::eVolumes;
6275 bool is0d = aMode & SMESH_Actor::e0DElements;
6276 bool isB = aMode & SMESH_Actor::eBallElem;
6278 QString modeStr ("e");
6279 modeStr += gDigitsSep; modeStr += QString::number(isE);
6280 modeStr += gDigitsSep; modeStr += "f";
6281 modeStr += gDigitsSep; modeStr += QString::number(isF);
6282 modeStr += gDigitsSep; modeStr += "v";
6283 modeStr += gDigitsSep; modeStr += QString::number(isV);
6284 modeStr += gDigitsSep; modeStr += "0d";
6285 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6286 modeStr += gDigitsSep; modeStr += "b";
6287 modeStr += gDigitsSep; modeStr += QString::number(isB);
6289 param = vtkParam + "Entities";
6290 ip->setParameter(entry, param, modeStr.toLatin1().data());
6296 aSmeshActor->GetSufaceColor(r, g, b, delta);
6297 QStringList colorStr;
6298 colorStr << "surface";
6299 colorStr << QString::number(r);
6300 colorStr << QString::number(g);
6301 colorStr << QString::number(b);
6303 colorStr << "backsurface";
6304 colorStr << QString::number(delta);
6306 aSmeshActor->GetVolumeColor(r, g, b, delta);
6307 colorStr << "volume";
6308 colorStr << QString::number(r);
6309 colorStr << QString::number(g);
6310 colorStr << QString::number(b);
6311 colorStr << QString::number(delta);
6313 aSmeshActor->GetEdgeColor(r, g, b);
6315 colorStr << QString::number(r);
6316 colorStr << QString::number(g);
6317 colorStr << QString::number(b);
6319 aSmeshActor->GetNodeColor(r, g, b);
6321 colorStr << QString::number(r);
6322 colorStr << QString::number(g);
6323 colorStr << QString::number(b);
6325 aSmeshActor->GetOutlineColor(r, g, b);
6326 colorStr << "outline";
6327 colorStr << QString::number(r);
6328 colorStr << QString::number(g);
6329 colorStr << QString::number(b);
6331 aSmeshActor->Get0DColor(r, g, b);
6332 colorStr << "elem0d";
6333 colorStr << QString::number(r);
6334 colorStr << QString::number(g);
6335 colorStr << QString::number(b);
6337 aSmeshActor->GetBallColor(r, g, b);
6339 colorStr << QString::number(r);
6340 colorStr << QString::number(g);
6341 colorStr << QString::number(b);
6343 aSmeshActor->GetFacesOrientationColor(r, g, b);
6344 colorStr << "orientation";
6345 colorStr << QString::number(r);
6346 colorStr << QString::number(g);
6347 colorStr << QString::number(b);
6349 param = vtkParam + "Colors";
6350 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6353 QStringList sizeStr;
6355 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6356 sizeStr << "outline";
6357 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6358 sizeStr << "elem0d";
6359 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6361 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6362 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6363 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6364 sizeStr << "shrink";
6365 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6366 sizeStr << "orientation";
6367 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6368 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6370 param = vtkParam + "Sizes";
6371 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6376 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6377 if( aMarkerType == VTK::MT_USER ) {
6378 markerStr += "custom";
6379 markerStr += gDigitsSep;
6380 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6384 markerStr += gDigitsSep;
6385 markerStr += QString::number( (int)aMarkerType );
6386 markerStr += gDigitsSep;
6387 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6390 param = vtkParam + "PointMarker";
6391 ip->setParameter(entry, param, markerStr.toLatin1().data());
6394 param = vtkParam + "Opacity";
6395 ip->setParameter(entry, param,
6396 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6399 param = vtkParam + "ClippingPlane";
6401 if( !aClippingPlaneInfoList.empty() ) {
6402 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6403 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6405 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6406 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6407 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6408 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6409 if( aSmeshActor == *anIter2 ) {
6410 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6411 QString::number( anId ).toLatin1().constData() );
6418 ip->setParameter( entry, param, "Off" );
6419 } // if (io->hasEntry())
6420 } // SMESH_Actor && hasIO
6422 } // while.. actors traversal
6426 } // if (SVTK view model)
6427 } // for (viewManagers)
6430 // data structures for clipping planes processing
6434 bool isOpenGLClipping;
6435 vtkIdType RelativeOrientation;
6438 int AbsoluteOrientation;
6439 double X, Y, Z, Dx, Dy, Dz;
6441 typedef std::list<TPlaneData> TPlaneDataList;
6442 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6444 typedef std::list<vtkActor*> TActorList;
6447 TActorList ActorList;
6448 SUIT_ViewManager* ViewManager;
6450 typedef std::list<TPlaneInfo> TPlaneInfoList;
6451 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6454 * \brief Restore visual parameters
6456 * This method is called after the study document is opened.
6457 * Restore visual parameters from AttributeParameter attribute(s)
6459 void SMESHGUI::restoreVisualParameters (int savePoint)
6462 Kernel_Utils::Localizer loc;
6464 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6465 if (!appStudy || !appStudy->studyDS())
6467 _PTR(Study) studyDS = appStudy->studyDS();
6469 // componentName is used for encoding of entries when storing them in IParameters
6470 std::string componentName = myComponentSMESH->ComponentDataType();
6473 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6474 componentName.c_str(),
6476 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6478 // restore custom markers and map of clipping planes
6479 TPlaneDataMap aPlaneDataMap;
6481 std::vector<std::string> properties = ip->getProperties();
6482 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6484 std::string property = *propIt;
6485 QString aPropertyName( property.c_str() );
6486 QString aPropertyValue( ip->getProperty( property ).c_str() );
6488 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6489 if( aPropertyNameList.isEmpty() )
6492 QString aPropertyType = aPropertyNameList[0];
6493 if( aPropertyType == "texture" )
6495 if( aPropertyNameList.size() != 2 )
6499 int anId = aPropertyNameList[1].toInt( &ok );
6500 if( !ok || anId < 1 )
6503 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6504 if( aPropertyValueList.size() != 2 )
6507 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6508 QString aMarkerTextureString = aPropertyValueList[1];
6509 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6510 if( aMarkerTextureStringList.size() != 3 )
6514 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6519 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6523 VTK::MarkerTexture aMarkerTexture;
6524 aMarkerTexture.push_back( aWidth );
6525 aMarkerTexture.push_back( aHeight );
6527 QString aMarkerTextureData = aMarkerTextureStringList[2];
6528 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6530 QChar aChar = aMarkerTextureData.at( i );
6531 if( aChar.isDigit() )
6532 aMarkerTexture.push_back( aChar.digitValue() );
6535 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6537 else if( aPropertyType == "ClippingPlane" )
6539 if( aPropertyNameList.size() != 3 )
6543 int aViewId = aPropertyNameList[1].toInt( &ok );
6544 if( !ok || aViewId < 0 )
6548 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6549 if( !ok || aClippingPlaneId < 0 )
6552 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6553 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6556 TPlaneData aPlaneData;
6557 aPlaneData.AbsoluteOrientation = false;
6558 aPlaneData.RelativeOrientation = 0;
6559 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6560 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6561 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6563 aPlaneData.Id = aClippingPlaneId;
6566 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6571 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6575 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6578 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6583 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6588 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6593 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6598 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6603 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6608 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6612 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6614 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6619 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6624 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6629 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6634 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6635 aPlaneDataList.push_back( aPlaneData );
6639 TPlaneInfoMap aPlaneInfoMap;
6641 std::vector<std::string> entries = ip->getEntries();
6643 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6645 // entry is a normal entry - it should be "decoded" (setting base address of component)
6646 QString entry (ip->decodeEntry(*entIt).c_str());
6648 // Check that the entry corresponds to a real object in the Study
6649 // as the object may be deleted or modified after the visual state is saved.
6650 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6651 if (!so) continue; //Skip the not existent entry
6653 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6654 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6656 std::vector<std::string>::iterator namesIt = paramNames.begin();
6657 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6659 // actors are stored in a map after displaying of them for
6660 // quicker access in the future: map < viewID to actor >
6661 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6663 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6665 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6666 // '_' is used as separator and should not be used in viewer type or parameter names.
6667 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6668 if (lst.size() != 3)
6671 QString viewerTypStr = lst[0];
6672 QString viewIndexStr = lst[1];
6673 QString paramNameStr = lst[2];
6676 int viewIndex = viewIndexStr.toUInt(&ok);
6677 if (!ok) // bad conversion of view index to integer
6681 if (viewerTypStr == SVTK_Viewer::Type())
6683 SMESH_Actor* aSmeshActor = 0;
6684 if (vtkActors.IsBound(viewIndex))
6685 aSmeshActor = vtkActors.Find(viewIndex);
6687 QList<SUIT_ViewManager*> lst;
6688 getApp()->viewManagers(viewerTypStr, lst);
6690 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6691 SUIT_ViewManager* vman = NULL;
6692 if (viewIndex >= 0 && viewIndex < lst.count())
6693 vman = lst.at(viewIndex);
6695 if (paramNameStr == "Visibility")
6697 if (!aSmeshActor && displayer() && vman)
6699 SUIT_ViewModel* vmodel = vman->getViewModel();
6700 // SVTK view model can be casted to SALOME_View
6701 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6703 // store displayed actor in a temporary map for quicker
6704 // access later when restoring other parameters
6705 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6706 vtkRenderer* Renderer = vtkView->getRenderer();
6707 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6708 vtkActorCollection* theActors = aCopy.GetActors();
6709 theActors->InitTraversal();
6710 bool isFound = false;
6711 vtkActor *ac = theActors->GetNextActor();
6712 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6713 if (ac->IsA("SMESH_Actor")) {
6714 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6715 if (aGeomAc->hasIO()) {
6716 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6717 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6719 vtkActors.Bind(viewIndex, aGeomAc);
6725 } // if (paramNameStr == "Visibility")
6728 // the rest properties "work" with SMESH_Actor
6731 QString val ((*valuesIt).c_str());
6734 if (paramNameStr == "Representation") {
6735 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6738 else if (paramNameStr == "IsShrunk") {
6740 if (!aSmeshActor->IsShrunk())
6741 aSmeshActor->SetShrink();
6744 if (aSmeshActor->IsShrunk())
6745 aSmeshActor->UnShrink();
6748 // Displayed entities
6749 else if (paramNameStr == "Entities") {
6750 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6751 int aEntityMode = SMESH_Actor::eAllEntity;
6752 for ( int i = 0; i < mode.count(); i+=2 ) {
6753 if ( i < mode.count()-1 ) {
6754 QString type = mode[i];
6755 bool val = mode[i+1].toInt();
6756 if ( type == "e" && !val )
6757 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6758 else if ( type == "f" && !val )
6759 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6760 else if ( type == "v" && !val )
6761 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6762 else if ( type == "0d" && !val )
6763 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6764 else if ( type == "b" && !val )
6765 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6768 aSmeshActor->SetEntityMode( aEntityMode );
6771 else if (paramNameStr == "Colors") {
6772 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6779 QColor outlineColor;
6780 QColor orientationColor;
6786 // below lines are required to get default values for delta coefficients
6787 // of backface color for faces and color of reversed volumes
6788 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6789 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6790 for ( int i = 0; i < colors.count(); i++ ) {
6791 QString type = colors[i];
6792 if ( type == "surface" ) {
6793 // face color is set by 3 values r:g:b, where
6794 // - r,g,b - is rgb color components
6795 if ( i+1 >= colors.count() ) break; // format error
6796 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6797 if ( i+2 >= colors.count() ) break; // format error
6798 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6799 if ( i+3 >= colors.count() ) break; // format error
6800 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6801 faceColor.setRgbF( r, g, b );
6804 else if ( type == "backsurface" ) {
6805 // backface color can be defined in several ways
6806 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6807 // - in latest versions, it is set as delta coefficient
6808 bool rgbOk = false, deltaOk;
6809 if ( i+1 >= colors.count() ) break; // format error
6810 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6811 int delta = colors[i+1].toInt( &deltaOk );
6813 if ( i+1 < colors.count() ) // index is shifted to 1
6814 g = colors[i+1].toDouble( &rgbOk );
6815 if ( rgbOk ) i++; // shift index
6816 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6817 b = colors[i+1].toDouble( &rgbOk );
6819 // - as currently there's no way to set directly backsurface color as it was before,
6820 // we ignore old dump where r,g,b triple was set
6821 // - also we check that delta parameter is set properly
6822 if ( !rgbOk && deltaOk )
6825 else if ( type == "volume" ) {
6826 // volume color is set by 4 values r:g:b:delta, where
6827 // - r,g,b - is a normal volume rgb color components
6828 // - delta - is a reversed volume color delta coefficient
6829 if ( i+1 >= colors.count() ) break; // format error
6830 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6831 if ( i+2 >= colors.count() ) break; // format error
6832 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6833 if ( i+3 >= colors.count() ) break; // format error
6834 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6835 if ( i+4 >= colors.count() ) break; // format error
6836 int delta = colors[i+4].toInt( &bOk );
6837 if ( !bOk ) break; // format error
6838 volumeColor.setRgbF( r, g, b );
6842 else if ( type == "edge" ) {
6843 // edge color is set by 3 values r:g:b, where
6844 // - r,g,b - is rgb color components
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 edgeColor.setRgbF( r, g, b );
6854 else if ( type == "node" ) {
6855 // node color is set by 3 values r:g:b, where
6856 // - r,g,b - is rgb color components
6857 if ( i+1 >= colors.count() ) break; // format error
6858 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6859 if ( i+2 >= colors.count() ) break; // format error
6860 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6861 if ( i+3 >= colors.count() ) break; // format error
6862 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6863 nodeColor.setRgbF( r, g, b );
6866 else if ( type == "elem0d" ) {
6867 // 0d element color is set by 3 values r:g:b, where
6868 // - r,g,b - is rgb color components
6869 if ( i+1 >= colors.count() ) break; // format error
6870 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6871 if ( i+2 >= colors.count() ) break; // format error
6872 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6873 if ( i+3 >= colors.count() ) break; // format error
6874 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6875 elem0dColor.setRgbF( r, g, b );
6878 else if ( type == "ball" ) {
6879 // ball color is set by 3 values r:g:b, where
6880 // - r,g,b - is rgb color components
6881 if ( i+1 >= colors.count() ) break; // format error
6882 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6883 if ( i+2 >= colors.count() ) break; // format error
6884 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6885 if ( i+3 >= colors.count() ) break; // format error
6886 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6887 ballColor.setRgbF( r, g, b );
6890 else if ( type == "outline" ) {
6891 // outline color is set by 3 values r:g:b, where
6892 // - r,g,b - is rgb color components
6893 if ( i+1 >= colors.count() ) break; // format error
6894 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6895 if ( i+2 >= colors.count() ) break; // format error
6896 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6897 if ( i+3 >= colors.count() ) break; // format error
6898 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6899 outlineColor.setRgbF( r, g, b );
6902 else if ( type == "orientation" ) {
6903 // orientation color is set by 3 values r:g:b, where
6904 // - r,g,b - is rgb color components
6905 if ( i+1 >= colors.count() ) break; // format error
6906 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6907 if ( i+2 >= colors.count() ) break; // format error
6908 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6909 if ( i+3 >= colors.count() ) break; // format error
6910 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6911 orientationColor.setRgbF( r, g, b );
6916 if ( nodeColor.isValid() )
6917 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6919 if ( edgeColor.isValid() )
6920 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6922 if ( faceColor.isValid() )
6923 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6925 if ( volumeColor.isValid() )
6926 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6927 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6928 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6930 if ( elem0dColor.isValid() )
6931 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6933 if ( ballColor.isValid() )
6934 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6936 if ( outlineColor.isValid() )
6937 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6938 // orientation color
6939 if ( orientationColor.isValid() )
6940 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6943 else if (paramNameStr == "Sizes") {
6944 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6947 int outlineWidth = -1;
6948 int elem0dSize = -1;
6949 //int ballSize = -1;
6950 double ballDiameter = -1.0;
6951 double ballScale = -1.0;
6952 double shrinkSize = -1;
6953 double orientationSize = -1;
6954 bool orientation3d = false;
6955 for ( int i = 0; i < sizes.count(); i++ ) {
6956 QString type = sizes[i];
6957 if ( type == "line" ) {
6958 // line (wireframe) width is given as single integer value
6959 if ( i+1 >= sizes.count() ) break; // format error
6960 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6964 if ( type == "outline" ) {
6965 // outline width is given as single integer value
6966 if ( i+1 >= sizes.count() ) break; // format error
6967 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6971 else if ( type == "elem0d" ) {
6972 // 0d element size is given as single integer value
6973 if ( i+1 >= sizes.count() ) break; // format error
6974 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6978 else if ( type == "ball" ) {
6979 // balls are specified by two values: size:scale, where
6980 // - size - is a integer value specifying size
6981 // - scale - is a double value specifying scale factor
6982 if ( i+1 >= sizes.count() ) break; // format error
6983 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6984 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6985 if ( i+2 >= sizes.count() ) break; // format error
6986 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6992 else if ( type == "shrink" ) {
6993 // shrink factor is given as single floating point value
6994 if ( i+1 >= sizes.count() ) break; // format error
6995 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6999 else if ( type == "orientation" ) {
7000 // orientation vectors are specified by two values size:3d, where
7001 // - size - is a floating point value specifying scale factor
7002 // - 3d - is a boolean
7003 if ( i+1 >= sizes.count() ) break; // format error
7004 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7005 if ( i+2 >= sizes.count() ) break; // format error
7006 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7007 orientationSize = v1;
7008 orientation3d = (bool)v2;
7012 // line (wireframe) width
7013 if ( lineWidth > 0 )
7014 aSmeshActor->SetLineWidth( lineWidth );
7016 if ( outlineWidth > 0 )
7017 aSmeshActor->SetOutlineWidth( outlineWidth );
7018 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7019 aSmeshActor->SetOutlineWidth( lineWidth );
7021 if ( elem0dSize > 0 )
7022 aSmeshActor->Set0DSize( elem0dSize );
7024 /*if ( ballSize > 0 )
7025 aSmeshActor->SetBallSize( ballSize );*/
7027 if ( ballDiameter > 0 )
7028 aSmeshActor->SetBallSize( ballDiameter );
7030 if ( ballScale > 0.0 )
7031 aSmeshActor->SetBallScale( ballScale );
7033 if ( shrinkSize > 0 )
7034 aSmeshActor->SetShrinkFactor( shrinkSize );
7035 // orientation vectors
7036 if ( orientationSize > 0 ) {
7037 aSmeshActor->SetFacesOrientationScale( orientationSize );
7038 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7042 else if (paramNameStr == "PointMarker") {
7043 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7044 if( data.count() >= 2 ) {
7046 int aParam1 = data[1].toInt( &ok );
7048 if( data[0] == "std" && data.count() == 3 ) {
7049 int aParam2 = data[2].toInt( &ok );
7050 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7052 else if( data[0] == "custom" ) {
7053 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7054 if( markerIt != myMarkerMap.end() ) {
7055 VTK::MarkerData aMarkerData = markerIt->second;
7056 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7063 else if (paramNameStr == "Opacity") {
7064 aSmeshActor->SetOpacity(val.toFloat());
7067 else if (paramNameStr.startsWith("ClippingPlane")) {
7068 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7069 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7070 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7071 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7072 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7073 // new format - val looks like "Off" or "0" (plane id)
7074 // (note: in new format "Off" value is used only for consistency,
7075 // so it is processed together with values in old format)
7076 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7077 if( anIsOldFormat ) {
7078 if (paramNameStr == "ClippingPlane1" || val == "Off")
7079 aSmeshActor->RemoveAllClippingPlanes();
7081 QList<SUIT_ViewManager*> lst;
7082 getApp()->viewManagers(viewerTypStr, lst);
7083 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7084 if (viewIndex >= 0 && viewIndex < lst.count()) {
7085 SUIT_ViewManager* vman = lst.at(viewIndex);
7086 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7088 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7090 SMESH::TActorList anActorList;
7091 anActorList.push_back( aSmeshActor );
7092 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7093 aPlane->myViewWindow = vtkView;
7094 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7095 aPlane->PlaneMode = aMode;
7096 bool isOpenGLClipping = ( bool )vals[1].toInt();
7097 aPlane->IsOpenGLClipping = isOpenGLClipping;
7098 if ( aMode == SMESH::Absolute ) {
7099 aPlane->myAbsoluteOrientation = vals[2].toInt();
7100 aPlane->X = vals[3].toFloat();
7101 aPlane->Y = vals[4].toFloat();
7102 aPlane->Z = vals[5].toFloat();
7103 aPlane->Dx = vals[6].toFloat();
7104 aPlane->Dy = vals[7].toFloat();
7105 aPlane->Dz = vals[8].toFloat();
7107 else if ( aMode == SMESH::Relative ) {
7108 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7109 aPlane->myDistance = vals[3].toFloat();
7110 aPlane->myAngle[0] = vals[4].toFloat();
7111 aPlane->myAngle[1] = vals[5].toFloat();
7115 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7116 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7117 aClippingPlaneInfo.Plane = aPlane;
7118 aClippingPlaneInfo.ActorList = anActorList;
7119 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7127 int aPlaneId = val.toInt( &ok );
7128 if( ok && aPlaneId >= 0 ) {
7129 bool anIsDefinedPlane = false;
7130 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7131 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7132 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7133 TPlaneInfo& aPlaneInfo = *anIter;
7134 if( aPlaneInfo.PlaneId == aPlaneId ) {
7135 aPlaneInfo.ActorList.push_back( aSmeshActor );
7136 anIsDefinedPlane = true;
7140 if( !anIsDefinedPlane ) {
7141 TPlaneInfo aPlaneInfo;
7142 aPlaneInfo.PlaneId = aPlaneId;
7143 aPlaneInfo.ActorList.push_back( aSmeshActor );
7144 aPlaneInfo.ViewManager = vman;
7146 // to make the list sorted by plane id
7147 anIter = aPlaneInfoList.begin();
7148 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7149 const TPlaneInfo& aPlaneInfoRef = *anIter;
7150 if( aPlaneInfoRef.PlaneId > aPlaneId )
7153 aPlaneInfoList.insert( anIter, aPlaneInfo );
7158 } // if (aSmeshActor)
7159 } // other parameters than Visibility
7161 } // for names/parameters iterator
7162 } // for entries iterator
7164 // take into account planes with empty list of actors referred to them
7165 QList<SUIT_ViewManager*> aVMList;
7166 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7168 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7169 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7170 int aViewId = aPlaneDataIter->first;
7171 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7172 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7174 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7176 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7177 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7178 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7179 const TPlaneData& aPlaneData = *anIter2;
7180 int aPlaneId = aPlaneData.Id;
7182 bool anIsFound = false;
7183 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7184 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7185 const TPlaneInfo& aPlaneInfo = *anIter3;
7186 if( aPlaneInfo.PlaneId == aPlaneId ) {
7193 TPlaneInfo aPlaneInfo; // ActorList field is empty
7194 aPlaneInfo.PlaneId = aPlaneId;
7195 aPlaneInfo.ViewManager = aViewManager;
7197 // to make the list sorted by plane id
7198 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7199 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7200 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7201 if( aPlaneInfoRef.PlaneId > aPlaneId )
7204 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7210 // add clipping planes to actors according to the restored parameters
7211 // and update the clipping plane map
7212 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7213 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7214 int aViewId = anIter1->first;
7215 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7217 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7218 if( anIter2 == aPlaneDataMap.end() )
7220 const TPlaneDataList& aPlaneDataList = anIter2->second;
7222 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7223 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7224 const TPlaneInfo& aPlaneInfo = *anIter3;
7225 int aPlaneId = aPlaneInfo.PlaneId;
7226 const TActorList& anActorList = aPlaneInfo.ActorList;
7227 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7231 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7235 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7237 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7238 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7239 const TPlaneData& aPlaneData = *anIter4;
7240 if( aPlaneData.Id == aPlaneId ) {
7241 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7242 aPlane->myViewWindow = aViewWindow;
7243 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7244 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7245 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7246 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7247 aPlane->X = aPlaneData.X;
7248 aPlane->Y = aPlaneData.Y;
7249 aPlane->Z = aPlaneData.Z;
7250 aPlane->Dx = aPlaneData.Dx;
7251 aPlane->Dy = aPlaneData.Dy;
7252 aPlane->Dz = aPlaneData.Dz;
7254 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7255 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7256 aPlane->myDistance = aPlaneData.Distance;
7257 aPlane->myAngle[0] = aPlaneData.Angle[0];
7258 aPlane->myAngle[1] = aPlaneData.Angle[1];
7261 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7262 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7263 aClippingPlaneInfo.Plane = aPlane;
7264 aClippingPlaneInfo.ActorList = anActorList;
7265 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7276 // update all VTK views
7277 QList<SUIT_ViewManager*> lst;
7278 getApp()->viewManagers(lst);
7279 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7280 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7281 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7282 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7283 // set OpenGL clipping planes
7284 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7285 vtkActorCollection* anAllActors = aCopy.GetActors();
7286 anAllActors->InitTraversal();
7287 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7288 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7289 anActor->SetOpenGLClippingPlane();
7291 vtkView->getRenderer()->ResetCameraClippingRange();
7298 \brief Adds preferences for dfont of VTK viewer
7300 \param pIf group identifier
7301 \param param parameter
7302 \return identifier of preferences
7304 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7306 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7308 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7311 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7312 fam.append( tr( "SMESH_FONT_COURIER" ) );
7313 fam.append( tr( "SMESH_FONT_TIMES" ) );
7315 setPreferenceProperty( tfont, "fonts", fam );
7317 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7318 if ( needSize ) f = f | QtxFontEdit::Size;
7319 setPreferenceProperty( tfont, "features", f );
7325 \brief Actions after hypothesis edition
7326 Updates object browser after hypothesis edition
7328 void SMESHGUI::onHypothesisEdit( int result )
7331 SMESHGUI::Modified();
7332 updateObjBrowser( true );
7336 \brief Actions after choosing menu of control modes
7337 Updates control mode actions according to current selection
7339 void SMESHGUI::onUpdateControlActions()
7341 SALOME_ListIO selected;
7342 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7343 aSel->selectedObjects( selected );
7345 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7346 if ( selected.Extent() ) {
7347 if ( selected.First()->hasEntry() ) {
7348 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7349 aControl = anActor->GetControlMode();
7350 SALOME_ListIteratorOfListIO it(selected);
7351 for ( it.Next(); it.More(); it.Next() ) {
7352 Handle(SALOME_InteractiveObject) anIO = it.Value();
7353 if ( anIO->hasEntry() ) {
7354 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7355 if ( aControl != anActor->GetControlMode() ) {
7356 aControl = SMESH_Actor::eNone;
7366 int anAction = ActionToControl( aControl, true );
7368 action( anAction )->setChecked( true );
7370 QMenu* send = (QMenu*)sender();
7371 QList<QAction*> actions = send->actions();
7372 for ( int i = 0; i < actions.size(); i++ )
7373 actions[i]->setChecked( false );
7379 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7380 \param pview view being closed
7382 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7383 #ifndef DISABLE_PLOT2DVIEWER
7384 //Crear all Plot2d Viewers if need.
7385 SMESH::ClearPlot2Viewers(pview);
7387 EmitSignalCloseView();
7390 void SMESHGUI::message( const QString& msg )
7393 QStringList data = msg.split("/");
7394 if ( data.count() > 0 ) {
7395 if ( data.first() == "mesh_loading" ) {
7397 QString entry = data.count() > 1 ? data[1] : QString();
7398 if ( entry.isEmpty() )
7401 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7403 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7406 name = SMESH::fromUtf8(obj->GetName());
7407 if ( name.isEmpty() )
7410 if ( data.last() == "stop" )
7411 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7413 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7414 QApplication::processEvents();
7420 \brief Connects or disconnects signals about activating and cloning view on the module slots
7421 \param pview view which is connected/disconnected
7423 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7427 SUIT_ViewManager* viewMgr = pview->getViewManager();
7429 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7430 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7432 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7433 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7438 \brief Return \c true if object can be renamed
7440 bool SMESHGUI::renameAllowed( const QString& entry) const {
7441 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7445 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7449 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7454 if(appStudy->isComponent(entry) || obj->isReference())
7457 // check type to prevent renaming of inappropriate objects
7458 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7459 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7460 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7461 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7462 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7463 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7470 Rename object by entry.
7471 \param entry entry of the object
7472 \param name new name of the object
7473 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7475 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7477 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7481 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7486 _PTR(Study) aStudy = appStudy->studyDS();
7491 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7493 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7498 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7499 _PTR(GenericAttribute) anAttr;
7500 _PTR(AttributeName) aName;
7502 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7504 // check type to prevent renaming of inappropriate objects
7505 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7506 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7507 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7508 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7509 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7510 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7511 if ( !name.isEmpty() ) {
7512 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7514 // update name of group object and its actor
7515 Handle(SALOME_InteractiveObject) IObject =
7516 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7518 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7519 if( !aGroupObject->_is_nil() ) {
7520 aGroupObject->SetName( qUtf8Printable(name) );
7521 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7522 anActor->setName( qUtf8Printable(name) );
7532 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7534 static QList<QColor> colors;
7536 if ( colors.isEmpty() ) {
7538 for (int s = 0; s < 2 ; s++)
7540 for (int v = 100; v >= 40; v = v - 20)
7542 for (int h = 0; h < 359 ; h = h + 60)
7544 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7549 static int currentColor = randomize( colors.size() );
7551 SALOMEDS::Color color;
7552 color.R = (double)colors[currentColor].red() / 255.0;
7553 color.G = (double)colors[currentColor].green() / 255.0;
7554 color.B = (double)colors[currentColor].blue() / 255.0;
7556 currentColor = (currentColor+1) % colors.count();