1 // Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_MG_ADAPTDRIVER.h"
64 #include "SMESHGUI_Make2DFrom3DOp.h"
65 #include "SMESHGUI_MakeNodeAtPointDlg.h"
66 #include "SMESHGUI_Measurements.h"
67 #include "SMESHGUI_MergeDlg.h"
68 #include "SMESHGUI_MeshInfo.h"
69 #include "SMESHGUI_MeshOp.h"
70 #include "SMESHGUI_MeshOrderOp.h"
71 #include "SMESHGUI_MeshPatternDlg.h"
72 #include "SMESHGUI_MeshUtils.h"
73 #include "SMESHGUI_MultiEditDlg.h"
74 #include "SMESHGUI_NodesDlg.h"
75 #include "SMESHGUI_OffsetDlg.h"
76 #include "SMESHGUI_Operations.h"
77 #include "SMESHGUI_PatternUtils.h"
78 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
79 #include "SMESHGUI_PropertiesDlg.h"
80 #include "SMESHGUI_RemoveElementsDlg.h"
81 #include "SMESHGUI_RemoveNodesDlg.h"
82 #include "SMESHGUI_RenumberingDlg.h"
83 #include "SMESHGUI_ReorientFacesDlg.h"
84 #include "SMESHGUI_RevolutionDlg.h"
85 #include "SMESHGUI_RotationDlg.h"
86 #include "SMESHGUI_ScaleDlg.h"
87 #include "SMESHGUI_Selection.h"
88 #include "SMESHGUI_SewingDlg.h"
89 #include "SMESHGUI_SingleEditDlg.h"
90 #include "SMESHGUI_SmoothingDlg.h"
91 #include "SMESHGUI_SpinBox.h"
92 #include "SMESHGUI_SplitBiQuad.h"
93 #include "SMESHGUI_SymmetryDlg.h"
94 #include "SMESHGUI_TranslationDlg.h"
95 #include "SMESHGUI_TransparencyDlg.h"
96 #include "SMESHGUI_Utils.h"
97 #include "SMESHGUI_VTKUtils.h"
99 #include "SMESH_version.h"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_Comment.hxx"
105 #include "SMESH_ControlsDef.hxx"
106 #include "SMESH_ScalarBarActor.h"
107 #include "SMESH_TypeFilter.hxx"
108 #include "SMESH_Component_Generator.hxx"
110 // SALOME GUI includes
111 #include <LightApp_DataOwner.h>
112 #include <LightApp_NameDlg.h>
113 #include <LightApp_Preferences.h>
114 #include <LightApp_SelectionMgr.h>
115 #include <LightApp_UpdateFlags.h>
116 #include <QtxFontEdit.h>
117 #include <QtxPopupMgr.h>
118 #include <QtxInfoPanel.h>
119 #include <SALOME_ListIO.hxx>
120 #include <SUIT_Desktop.h>
121 #include <SUIT_FileDlg.h>
122 #include <SUIT_MessageBox.h>
123 #include <SUIT_OverrideCursor.h>
124 #include <SUIT_ResourceMgr.h>
125 #include <SUIT_Session.h>
126 #include <SVTK_Renderer.h>
127 #include <SVTK_ViewManager.h>
128 #include <SVTK_ViewModel.h>
129 #include <SVTK_ViewWindow.h>
130 #include <SalomeApp_Application.h>
131 #include <SalomeApp_CheckFileDlg.h>
132 #include <SalomeApp_DataObject.h>
133 #include <SalomeApp_Study.h>
134 #include <SalomeApp_Tools.h>
135 #include <VTKViewer_Algorithm.h>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
147 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
150 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
151 #include <QApplication>
153 #include <QDialogButtonBox>
157 #include <QTextStream>
161 #include <boost/shared_ptr.hpp>
164 #include <vtkCallbackCommand.h>
165 #include <vtkCamera.h>
166 #include <vtkLookupTable.h>
167 #include <vtkPlane.h>
168 #include <vtkRenderer.h>
170 // SALOME KERNEL includes
171 #include <Basics_Utils.hxx>
172 #include <SALOMEDSClient_ClientFactory.hxx>
173 #include <SALOMEDSClient_IParameters.hxx>
174 #include <SALOMEDSClient_SComponent.hxx>
175 #include <SALOMEDSClient_StudyBuilder.hxx>
176 #include <SALOMEDS_SObject.hxx>
177 #include <SALOMEDS_Study.hxx>
178 #include <SALOME_GenericObj_wrap.hxx>
179 #include <SALOME_LifeCycleCORBA.hxx>
180 #include <utilities.h>
183 #include <Standard_ErrorHandler.hxx>
184 #include <NCollection_DataMap.hxx>
185 #include <NCollection_DoubleMap.hxx>
187 // Below macro, when uncommented, switches on simplified (more performant) algorithm
188 // of auto-color picking up
189 #define SIMPLE_AUTOCOLOR
194 //=============================================================
195 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
198 void ExportMeshToFile(int theCommandID);
200 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
202 void SetDisplayEntity(int theCommandID);
204 int ActionToControl( int theID, bool theReversed = false );
206 void Control( int theCommandID );
209 //================================================================================
211 * \brief Reads meshes from file
213 //================================================================================
215 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
219 std::string myExtension;
221 if ( theCommandID == SMESHOp::OpImportMED ||
222 theCommandID == SMESHOp::OpPopupImportMED ) {
223 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
224 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
226 else if ( theCommandID == SMESHOp::OpImportUNV ||
227 theCommandID == SMESHOp::OpPopupImportUNV ) {
228 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
230 else if ( theCommandID == SMESHOp::OpImportDAT ||
231 theCommandID == SMESHOp::OpPopupImportDAT ) {
232 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
234 else if ( theCommandID == SMESHOp::OpImportSTL ||
235 theCommandID == SMESHOp::OpPopupImportSTL ) {
236 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
238 else if ( theCommandID == SMESHOp::OpImportCGNS ||
239 theCommandID == SMESHOp::OpPopupImportCGNS ) {
240 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
242 else if ( theCommandID == SMESHOp::OpImportSAUV ||
243 theCommandID == SMESHOp::OpPopupImportSAUV ) {
244 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
245 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
247 else if ( theCommandID == SMESHOp::OpImportGMF ||
248 theCommandID == SMESHOp::OpPopupImportGMF ) {
249 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
250 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
253 QString anInitialPath = "";
254 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
255 anInitialPath = QDir::currentPath();
257 QStringList filenames;
258 bool toCreateGroups = true;
260 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
261 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
262 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
263 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
264 // fd->setNameFilters( filter );
265 // fd->SetChecked( true );
267 // filenames << fd->selectedFile();
268 // toCreateGroups = fd->IsChecked();
274 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
277 QObject::tr( "SMESH_IMPORT_MESH" ) );
279 if ( filenames.count() > 0 )
281 SUIT_OverrideCursor wc;
282 _PTR(Study) aStudy = SMESH::getStudy();
285 QStringList anEntryList;
286 bool isEmpty = false;
287 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
289 QString filename = *it;
290 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
292 switch ( theCommandID ) {
293 case SMESHOp::OpImportDAT:
294 case SMESHOp::OpPopupImportDAT:
296 // DAT format (currently unsupported)
297 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
298 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
301 case SMESHOp::OpImportUNV:
302 case SMESHOp::OpPopupImportUNV:
305 aMeshes->length( 1 );
306 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
307 if ( aMeshes[0]->_is_nil() )
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
312 case SMESHOp::OpImportMED:
313 case SMESHOp::OpPopupImportMED:
316 SMESH::DriverMED_ReadStatus res;
317 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
318 if ( res != SMESH::DRS_OK ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
324 case SMESHOp::OpImportSTL:
325 case SMESHOp::OpPopupImportSTL:
328 aMeshes->length( 1 );
329 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
330 if ( aMeshes[0]->_is_nil() ) {
331 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
332 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
336 case SMESHOp::OpImportCGNS:
337 case SMESHOp::OpPopupImportCGNS:
340 SMESH::DriverMED_ReadStatus res;
341 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
342 if ( res != SMESH::DRS_OK ) {
343 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
344 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
348 case SMESHOp::OpImportSAUV:
349 case SMESHOp::OpPopupImportSAUV:
352 SMESH::DriverMED_ReadStatus res;
353 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
354 if ( res != SMESH::DRS_OK ) {
355 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
356 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
360 case SMESHOp::OpImportGMF:
361 case SMESHOp::OpPopupImportGMF:
364 SMESH::ComputeError_var res;
365 aMeshes->length( 1 );
366 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
369 if ( res->code != SMESH::DRS_OK ) {
370 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
371 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
372 if ( strlen( res->comment.in() ) > 0 ) {
373 errors.back() += ": ";
374 errors.back() += res->comment.in();
381 catch ( const SALOME::SALOME_Exception& S_ex ) {
382 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
383 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
386 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
388 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
390 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
391 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
392 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
393 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
394 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
396 anEntryList.append( aMeshSO->GetID().c_str() );
404 // update Object browser
405 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
407 // browse to the published meshes
408 if( LightApp_Application* anApp =
409 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
410 anApp->browseObjects( anEntryList );
412 // show Error message box if there were errors
413 if ( errors.count() > 0 ) {
414 SUIT_MessageBox::critical( SMESHGUI::desktop(),
415 QObject::tr( "SMESH_ERROR" ),
416 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
419 // show warning message box, if some imported mesh is empty
421 SUIT_MessageBox::warning( SMESHGUI::desktop(),
422 QObject::tr( "SMESH_WRN_WARNING" ),
423 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
428 //================================================================================
430 * \brief Export selected meshes or groups into a file
432 //================================================================================
434 void ExportMeshToFile( int theCommandID )
436 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
437 SALOME_ListIO selected;
439 aSel->selectedObjects( selected );
441 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
442 theCommandID == SMESHOp::OpPopupExportDAT );
443 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
444 theCommandID == SMESHOp::OpPopupExportMED );
445 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
446 theCommandID == SMESHOp::OpPopupExportUNV );
447 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
448 theCommandID == SMESHOp::OpPopupExportSTL );
449 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
450 theCommandID == SMESHOp::OpPopupExportCGNS );
451 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
452 theCommandID == SMESHOp::OpPopupExportSAUV );
453 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
454 theCommandID == SMESHOp::OpPopupExportGMF );
456 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
457 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
459 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
460 bool aCheckWarn = true;
462 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
464 // get mesh object from selection and check duplication of their names
465 bool hasDuplicatedMeshNames = false;
466 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
467 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
468 SALOME_ListIteratorOfListIO It( selected );
469 for( ; It.More(); It.Next() )
471 Handle(SALOME_InteractiveObject) anIObject = It.Value();
472 SMESH::SMESH_IDSource_var aMeshItem =
473 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
474 if ( aMeshItem->_is_nil() ) {
475 SUIT_MessageBox::warning( SMESHGUI::desktop(),
476 QObject::tr( "SMESH_WRN_WARNING" ),
477 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
480 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
481 if ( aCheckWarn && !aGroup->_is_nil() )
483 QMessageBox msgBox(SUIT_MessageBox::Warning,
484 QObject::tr("SMESH_WRN_WARNING"),
485 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
486 QMessageBox::StandardButton::NoButton,
487 SMESHGUI::desktop());
488 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
489 msgBox.addButton(QMessageBox::Ok);
490 msgBox.addButton(QMessageBox::Cancel);
491 msgBox.setDefaultButton(QMessageBox::Cancel);
492 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
493 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
494 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
495 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
496 if ( msgBox.exec() != QMessageBox::Ok )
499 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
500 resMgr->setValue( "SMESH", "show_warning", false);
503 QString aMeshName = anIObject->getName();
505 // check for name duplications
506 if ( !hasDuplicatedMeshNames )
507 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
508 if( aMeshName == (*aMeshIter).second ) {
509 hasDuplicatedMeshNames = true;
514 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
517 if( hasDuplicatedMeshNames && isMED ) {
518 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
519 QObject::tr("SMESH_WRN_WARNING"),
520 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
521 QObject::tr("SMESH_BUT_YES"),
522 QObject::tr("SMESH_BUT_NO"), 0, 1);
527 aMeshIter = aMeshList.begin();
528 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
529 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
530 QString aMeshName = (*aMeshIter).second;
532 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
534 // check for equal group names within each mesh
535 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
536 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
537 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
538 int aRet = SUIT_MessageBox::warning
539 (SMESHGUI::desktop(),
540 QObject::tr("SMESH_WRN_WARNING"),
541 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
542 QObject::tr("SMESH_BUT_YES"),
543 QObject::tr("SMESH_BUT_NO"), 0, 1);
550 // Warn the user about presence of not supported elements
552 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
556 notSupportedElemTypes.push_back( SMESH::Entity_0D );
557 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
562 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
563 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
564 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
566 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
567 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
568 notSupportedElemTypes.push_back( SMESH::Entity_0D );
569 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
574 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
575 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
576 notSupportedElemTypes.push_back( SMESH::Entity_0D );
577 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
582 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
587 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
588 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
589 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
590 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
591 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
592 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
593 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
594 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
599 notSupportedElemTypes.push_back( SMESH::Entity_0D );
600 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
601 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
602 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
603 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
604 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
605 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
606 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
607 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
608 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
610 if ( ! notSupportedElemTypes.empty() )
612 SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
613 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
614 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
615 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
617 if ( !presentNotSupported.empty() )
620 const char* typeMsg[] = {
621 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
622 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
623 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
624 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
625 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
626 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
627 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
628 "SMESH_BIQUADRATIC_PENTAHEDRONS",
629 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
631 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
632 static_assert( sizeof(typeMsg) / sizeof(const char*) == SMESH::Entity_Last,
633 "Update names of EntityType's!!!" );
635 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
636 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
637 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
638 if ( iType != presentNotSupported.size() - 1 )
639 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
641 int aRet = SUIT_MessageBox::warning
642 (SMESHGUI::desktop(),
643 QObject::tr("SMESH_WRN_WARNING"),
644 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
645 QObject::tr("SMESH_BUT_YES"),
646 QObject::tr("SMESH_BUT_NO"), 0, 1);
651 // Get parameters of export operation
654 int aFormat =-1; // for MED version used for write
655 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
657 // Init the parameters with the default values
658 bool aIsASCII_STL = true;
659 bool toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
660 bool toOverwrite = true;
661 bool toFindOutDim = true;
662 bool toRenumber = true;
663 double zTol = resMgr->doubleValue( "SMESH", "med_ztolerance", 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 ( isGMF ) // Export w/o options
675 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
676 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
677 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
679 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
680 anInitialPath + QString("/") + aMeshName,
681 aFilter, aTitle, false);
683 else if ( isCGNS || isUNV || isDAT ) // Export to [ CGNS | UNV | DAT ] - one option
685 const char* theOptionResource = isCGNS ? "cgns_group_elems_by_type" : "export_renumber";
686 bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
688 QStringList checkBoxes;
689 checkBoxes << QObject::tr( isCGNS ? "CGNS_EXPORT_ELEMS_BY_TYPE" : "SMESH_RENUMBER" );
691 SalomeApp_CheckFileDlg* fd =
692 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
693 fd->setWindowTitle( aTitle );
695 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
697 fd->setNameFilter( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
699 fd->setNameFilter( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
700 if ( !anInitialPath.isEmpty() )
701 fd->setDirectory( anInitialPath );
702 fd->selectFile( aMeshName );
703 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
704 fd->setValidator( fv );
705 fd->SetChecked( option, 0 );
708 aFilename = fd->selectedFile();
709 toOverwrite = fv->isOverwrite( aFilename );
710 option = fd->IsChecked( 0 );
711 SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
712 ( isCGNS ? toCreateGroups : toRenumber ) = option;
716 else if ( isSTL ) // Export to STL
718 QMap<QString, int> aFilterMap;
719 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
720 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
723 QMap<QString, int>::const_iterator it = aFilterMap.begin();
724 for ( ; it != aFilterMap.end(); ++it )
725 filters.push_back( it.key() );
727 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
728 fd->setWindowTitle( aTitle );
729 fd->setNameFilters( filters );
730 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
731 if ( !anInitialPath.isEmpty() )
732 fd->setDirectory( anInitialPath );
733 fd->selectFile(aMeshName);
737 aFilename = fd->selectedFile();
738 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
743 else if ( isMED || isSAUV ) // Export to MED or SAUV
745 int defaultVersion = 0;
746 QMap<QString, int> aFilterMap;
748 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
749 //QString vmed (aMesh->GetVersionString(-1, 2));
750 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
751 if ( mvok->length() > 0)
752 defaultVersion = mvok[0]; // the current version to set the default filter on it
753 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
755 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
756 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
760 aFilterMap.insert("All files (*)", -1 );
761 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
762 aFilterMap.insert("SAUV files (*.sauve)", -1 );
765 QMap<QString, int>::const_iterator it = aFilterMap.begin();
766 QString aDefaultFilter = it.key();
767 for ( ; it != aFilterMap.end(); ++it ) {
768 filters.push_back( it.key() );
769 if (it.value() == defaultVersion) // explicit default for MED = current MED version
770 aDefaultFilter = it.key();
772 QStringList checkBoxes;
773 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
775 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
776 QList< QWidget* > wdgList;
777 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
778 wdgList.append( fieldSelWdg );
780 QWidget* zTolWdg = new QWidget();
781 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
782 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
783 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
784 zTolLayout->addWidget( zTolCheck );
785 zTolLayout->addWidget( zTolSpin );
786 zTolLayout->setMargin( 0 );
787 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
788 zTolSpin->setValue( zTol );
789 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
790 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
791 zTolSpin ->setEnabled( zTolCheck->isChecked() );
792 wdgList.append( zTolWdg );
794 SalomeApp_CheckFileDlg* fd =
795 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
796 fd->setWindowTitle( aTitle );
797 fd->setNameFilters( filters );
798 fd->selectNameFilter( aDefaultFilter );
799 fd->SetChecked( toCreateGroups, 0 );
800 fd->SetChecked( toFindOutDim, 1 );
801 if ( !anInitialPath.isEmpty() )
802 fd->setDirectory( anInitialPath );
803 fd->selectFile(aMeshName);
806 QListView *lview = fd->findChild<QListView*>("listView");
808 lview->setMinimumHeight(200);
810 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
812 tview->setMinimumHeight(200);
815 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
816 fd->setValidator( fv );
821 //MESSAGE("******* Loop on file dialog ***********");
824 aFilename = fd->selectedFile();
826 aFilename = QString::null;
829 aFormat = aFilterMap[fd->selectedNameFilter()];
830 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
831 toOverwrite = fv->isOverwrite(aFilename);
832 //MESSAGE("toOverwrite:" << toOverwrite);
834 if ( !aFilename.isEmpty() ) {
836 // append is only possible if the existing file format is compatible
837 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
838 MESSAGE("Append check, isVersionOk:" << isVersionOk);
839 if ( !isVersionOk ) {
840 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
841 QObject::tr("SMESH_WRN_WARNING"),
842 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
843 QObject::tr("SMESH_BUT_YES"),
844 QObject::tr("SMESH_BUT_NO"), 0, 1);
848 //MESSAGE("incompatible MED file version for add, overwrite accepted");
854 //MESSAGE("incompatible MED file version for add, overwrite refused");
857 QStringList aMeshNamesCollisionList;
858 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
859 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
860 QString anExistingMeshName( aMeshNames[ i ] );
861 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
862 QString anExportMeshName = (*aMeshIter).second;
863 if( anExportMeshName == anExistingMeshName ) {
864 aMeshNamesCollisionList.append( anExportMeshName );
869 if( !aMeshNamesCollisionList.isEmpty() ) {
871 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
872 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
873 QObject::tr("SMESH_WRN_WARNING"),
874 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
875 QObject::tr("SMESH_BUT_YES"),
876 QObject::tr("SMESH_BUT_NO"),
877 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
878 MESSAGE("answer collision name " << aRet);
889 toCreateGroups = fd->IsChecked(0);
890 toFindOutDim = fd->IsChecked(1);
891 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
892 fieldSelWdg->GetSelectedFields();
893 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
895 if ( !fieldSelWdg->parent() )
897 if ( !zTolWdg->parent() )
908 if ( !aFilename.isEmpty() ) {
909 // Check whether the file already exists and delete it if yes
910 QFile aFile( aFilename );
911 if ( aFile.exists() && toOverwrite )
913 SUIT_OverrideCursor wc;
916 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
917 // bool Renumber = false;
918 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
920 // Renumber= resMgr->booleanValue("renumbering");
922 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
923 // aMeshEditor->RenumberNodes();
924 // aMeshEditor->RenumberElements();
925 // if ( SMESHGUI::automaticUpdate() )
926 // SMESH::UpdateView();
928 if ( isMED && isOkToWrite )
930 const bool saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
931 aMeshIter = aMeshList.begin();
932 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
934 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
935 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
936 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
937 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
939 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
940 toCreateGroups, aFormat,
941 toOverwrite && aMeshIndex == 0, toFindOutDim,
942 fields, geoAssFields.toLatin1().data(), zTol, saveNumbers );
947 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
949 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
950 if( !aMeshItem->_is_nil() )
951 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
956 if ( aMeshOrGroup->_is_equivalent( aMesh ))
957 aMesh->ExportDAT( aFilename.toUtf8().data(), toRenumber );
959 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
963 if ( aMeshOrGroup->_is_equivalent( aMesh ))
964 aMesh->ExportUNV( aFilename.toUtf8().data(), toRenumber );
966 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
970 if ( aMeshOrGroup->_is_equivalent( aMesh ))
971 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
973 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
977 aMeshIter = aMeshList.begin();
978 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
980 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
981 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
982 aMeshItem->ExportCGNS( aMeshOrGroup,
983 aFilename.toUtf8().data(),
984 toOverwrite && aMeshIndex == 0,
990 toCreateGroups = true;
991 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
994 catch (const SALOME::SALOME_Exception& S_ex)
997 if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
998 strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
1000 SUIT_MessageBox::critical(SMESHGUI::desktop(),
1001 QObject::tr("SMESH_WRN_WARNING"),
1002 QObject::tr(S_ex.details.text.in() ));
1004 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1005 QObject::tr("SMESH_WRN_WARNING"),
1006 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1012 inline void InverseEntityMode(unsigned int& theOutputMode,
1013 unsigned int theMode)
1015 bool anIsNotPresent = ~theOutputMode & theMode;
1017 theOutputMode |= theMode;
1019 theOutputMode &= ~theMode;
1022 void SetDisplayEntity(int theCommandID)
1024 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1025 SALOME_ListIO selected;
1027 aSel->selectedObjects( selected );
1029 if ( selected.Extent() >= 1 ) {
1030 SUIT_OverrideCursor wc;
1031 SALOME_ListIteratorOfListIO It( selected );
1032 for( ; It.More(); It.Next()){
1033 Handle(SALOME_InteractiveObject) IObject = It.Value();
1034 if(IObject->hasEntry()){
1035 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1036 unsigned int aMode = anActor->GetEntityMode();
1037 switch(theCommandID){
1038 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1039 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1040 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1041 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1042 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1043 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1046 anActor->SetEntityMode(aMode);
1055 SalomeApp_Application* app =
1056 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1060 LightApp_SelectionMgr* aSel = app->selectionMgr();
1061 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1062 if ( !aSel || !appStudy )
1065 SALOME_ListIO selected;
1066 aSel->selectedObjects( selected );
1067 if ( selected.IsEmpty() )
1070 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1072 _PTR(Study) aStudy = appStudy->studyDS();
1073 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1074 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1075 if ( aMainObject->_is_nil() )
1078 SUIT_OverrideCursor wc;
1080 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1082 QList<SALOMEDS::Color> aReservedColors;
1084 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1085 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1087 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1089 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1090 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1091 #else // old algorithm for auto-colors
1092 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1093 aReservedColors.append( aColor );
1094 #endif // SIMPLE_AUTOCOLOR
1095 aGroupObject->SetColor( aColor );
1097 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1098 if ( aGroupSObject ) {
1101 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1102 switch ( aGroupObject->GetType ()) {
1104 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1106 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1108 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1110 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1112 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1113 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1116 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1117 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1123 SMESH::RepaintCurrentView();
1126 void OverallMeshQuality()
1128 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1129 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1130 SALOME_ListIO selected;
1132 aSel->selectedObjects( selected );
1134 if ( selected.IsEmpty() ) return;
1135 SALOME_ListIteratorOfListIO It( selected );
1136 for ( ; It.More(); It.Next() ) {
1137 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1138 ctrlDlg->showInfo( It.Value() );
1143 QString functorToString( SMESH::Controls::FunctorPtr f )
1145 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1146 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1147 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1149 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1150 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1151 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1152 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1153 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1154 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1155 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1156 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1157 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1158 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1159 type = QObject::tr( "WARP_ELEMENTS" );
1160 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1161 type = QObject::tr( "TAPER_ELEMENTS" );
1162 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1163 type = QObject::tr( "SKEW_ELEMENTS" );
1164 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1165 type = QObject::tr( "AREA_ELEMENTS" );
1166 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1167 type = QObject::tr( "LENGTH_EDGES" );
1168 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1169 type = QObject::tr( "LENGTH2D_EDGES" );
1170 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1171 type = QObject::tr( "DEFLECTION2D_FACES" );
1172 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1173 type = QObject::tr( "MULTI_BORDERS" );
1174 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1175 type = QObject::tr( "MULTI2D_BORDERS" );
1176 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1177 type = QObject::tr( "FREE_NODES" );
1178 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1179 type = QObject::tr( "FREE_EDGES" );
1180 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1181 type = QObject::tr( "FREE_BORDERS" );
1182 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1183 type = QObject::tr( "FREE_FACES" );
1184 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1185 type = QObject::tr( "BARE_BORDER_VOLUME" );
1186 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1187 type = QObject::tr( "BARE_BORDER_FACE" );
1188 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1189 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1190 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1191 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1192 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1193 type = QObject::tr( "EQUAL_NODE" );
1194 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1195 type = QObject::tr( "EQUAL_EDGE" );
1196 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1197 type = QObject::tr( "EQUAL_FACE" );
1198 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1199 type = QObject::tr( "EQUAL_VOLUME" );
1200 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1201 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1205 void SaveDistribution()
1207 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1208 SALOME_ListIO selected;
1210 aSel->selectedObjects( selected );
1212 if ( selected.Extent() == 1 ) {
1213 Handle(SALOME_InteractiveObject) anIO = selected.First();
1214 if ( anIO->hasEntry() ) {
1215 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1217 anActor->GetScalarBarActor() &&
1218 anActor->GetControlMode() != SMESH_Actor::eNone )
1220 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1221 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1222 if ( aScalarBarActor && aFunctor ) {
1223 SMESH::Controls::NumericalFunctor* aNumFun =
1224 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1226 std::vector<smIdType> elements;
1227 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1228 if ( mesh->_is_nil() ) {
1229 SMESH::SMESH_IDSource_var idSource =
1230 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1231 if ( !idSource->_is_nil() )
1233 SMESH::smIdType_array_var ids = idSource->GetIDs();
1234 elements.resize( ids->length() );
1235 for ( unsigned i = 0; i < elements.size(); ++i )
1236 elements[i] = ids[i];
1239 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1240 vtkLookupTable* lookupTable =
1241 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1242 double * minmax = lookupTable->GetRange();
1243 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1244 std::vector<int> nbEvents;
1245 std::vector<double> funValues;
1246 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1247 elements, minmax, isLogarithmic );
1248 QString anInitialPath = "";
1249 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1250 anInitialPath = QDir::currentPath();
1251 QString aMeshName = anIO->getName();
1253 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1254 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1255 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1256 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1257 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1260 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1262 if ( !aFilename.isEmpty() ) {
1263 QFile f( aFilename );
1264 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1265 QTextStream out( &f );
1266 out << "# Mesh: " << aMeshName << endl;
1267 out << "# Control: " << functorToString( aFunctor ) << endl;
1269 out.setFieldWidth( 10 );
1270 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1271 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1282 void ShowElement( int theCommandID )
1284 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1285 SALOME_ListIO selected;
1287 aSel->selectedObjects( selected );
1289 if ( selected.Extent() == 1 ) {
1290 Handle(SALOME_InteractiveObject) anIO = selected.First();
1291 if ( anIO->hasEntry() ) {
1292 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1294 anActor->GetScalarBarActor() &&
1295 anActor->GetControlMode() != SMESH_Actor::eNone )
1297 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1298 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1299 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1301 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1302 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1309 #ifndef DISABLE_PLOT2DVIEWER
1310 void PlotDistribution()
1312 SalomeApp_Application* app =
1313 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1317 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1318 SALOME_ListIO selected;
1320 aSel->selectedObjects( selected );
1322 if ( selected.Extent() == 1 ) {
1323 Handle(SALOME_InteractiveObject) anIO = selected.First();
1324 if ( anIO->hasEntry() ) {
1325 //Find Actor by entry before getting Plot2d viewer,
1326 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1327 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1329 SUIT_ViewManager* aViewManager =
1330 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1334 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1338 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1342 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1344 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1345 QString functorName = functorToString( anActor->GetFunctor());
1346 QString aHistogramName("%1 : %2");
1347 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1348 aHistogram->setName(aHistogramName);
1349 aHistogram->setHorTitle(functorName);
1350 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1351 aPlot->displayObject(aHistogram, true);
1356 #endif //DISABLE_PLOT2DVIEWER
1358 void DisableAutoColor()
1360 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1361 SALOME_ListIO selected;
1363 aSel->selectedObjects( selected );
1365 if ( selected.Extent() ) {
1366 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1367 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1368 if ( !aMesh->_is_nil() ) {
1369 aMesh->SetAutoColor( false );
1376 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1377 SALOME_ListIO selected;
1379 aSel->selectedObjects( selected );
1380 if ( selected.Extent() )
1382 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1383 _PTR(Study) aStudy = SMESH::getStudy();
1384 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1386 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1387 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1394 // Break link with Shaper model
1395 void breakShaperLink()
1397 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1398 SALOME_ListIO selected;
1400 aSel->selectedObjects(selected);
1401 if (selected.Extent()) {
1402 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1403 _PTR(Study) aStudy = SMESH::getStudy();
1404 std::string aEntry = anIObject->getEntry();
1405 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1407 std::string aName = aSObj->GetName();
1408 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1409 QObject::tr("SMESH_WRN_WARNING"),
1410 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1411 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1412 if (aRes == SUIT_MessageBox::Yes) {
1413 SUIT_DataOwnerPtrList aList;
1414 aSel->selected(aList, "ObjectBrowser", true);
1415 SUIT_DataOwner* aOwn = aList.first();
1416 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1417 QString aREntry = sowner->entry();
1419 static GEOM::GEOM_Gen_var geomGen;
1420 if (CORBA::is_nil(geomGen)) {
1421 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1422 (SUIT_Session::session()->activeApplication());
1424 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1425 Engines::EngineComponent_var comp =
1426 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1427 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1430 if (!CORBA::is_nil(geomGen))
1432 geomGen->BreakLink(aREntry.toStdString().c_str());
1433 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1435 // remove actors whose objects are removed by BreakLink()
1436 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1437 SUIT_ViewWindow* wnd;
1438 foreach(wnd, wndList)
1439 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1447 //================================================================================
1449 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1450 * which means that the mesh can't be modified. It should be either re-computed
1451 * or breakShaperLink()'ed. Warn the user about it.
1453 //================================================================================
1455 bool warnOnGeomModif()
1457 SALOME_ListIO selected;
1458 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1459 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1461 SALOME_ListIteratorOfListIO It( selected );
1462 for ( ; It.More(); It.Next() )
1464 Handle(SALOME_InteractiveObject) io = It.Value();
1465 if ( !io->hasEntry() ) continue;
1466 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1467 SMESH::SMESH_Mesh_var mesh;
1468 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1470 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1471 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1472 if ( isrc->_is_nil() )
1473 so = so->GetFather();
1475 mesh = isrc->GetMesh();
1477 if ( mesh->_is_nil() ) continue;
1478 so = SMESH::FindSObject( mesh );
1479 if ( !so ) continue;
1480 _PTR(GenericAttribute) attr;
1481 so->FindAttribute( attr, "AttributePixMap" );
1482 _PTR(AttributePixMap) pixmap = attr;
1483 if ( !pixmap ) continue;
1485 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1487 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1488 QObject::tr("SMESH_WRN_WARNING"),
1489 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1496 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1498 SALOME_ListIO selected;
1499 SalomeApp_Application* app =
1500 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1504 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1505 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1506 if ( !aSel || !appStudy )
1509 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1510 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1511 aModule->EmitSignalDeactivateDialog();
1512 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1513 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1518 aSel->selectedObjects( selected );
1520 if ( selected.Extent() >= 1 )
1522 switch ( theCommandID ) {
1523 case SMESHOp::OpTransparency:
1525 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1526 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1529 case SMESHOp::OpProperties:
1532 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1533 QColor orientationColor, outlineColor, volumeColor;
1534 int deltaF = 0, deltaV = 0;
1537 double ballScale = 1.0;
1539 int outlineWidth = 1;
1540 double shrinkCoef = 0.0;
1541 double orientationScale = 0.0;
1542 bool orientation3d = false;
1543 VTK::MarkerType markerType = VTK::MT_NONE;
1544 VTK::MarkerScale markerScale = VTK::MS_NONE;
1546 bool hasNodes = false;
1547 int presentEntities = 0;
1548 bool firstTime = true;
1550 SALOME_ListIteratorOfListIO It( selected );
1551 for ( ; It.More(); It.Next() ) {
1552 Handle(SALOME_InteractiveObject) IObject = It.Value();
1553 if ( !IObject->hasEntry() ) continue;
1554 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1555 if ( !anActor || !anActor->GetObject() ) continue;
1558 // nodes: color, marker
1559 anActor->GetNodeColor( color[0], color[1], color[2] );
1560 nodeColor.setRgbF( color[0], color[1], color[2] );
1561 markerType = anActor->GetMarkerType();
1562 markerScale = anActor->GetMarkerScale();
1563 markerId = anActor->GetMarkerTexture();
1564 // edges: color, width
1565 anActor->GetEdgeColor( color[0], color[1], color[2] );
1566 edgeColor.setRgbF( color[0], color[1], color[2] );
1567 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1568 // faces: front color, back color (delta)
1569 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1570 faceColor.setRgbF( color[0], color[1], color[2] );
1571 // faces: front color, back color (delta)
1572 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1573 volumeColor.setRgbF( color[0], color[1], color[2] );
1574 // 0d elements: color, size
1575 anActor->Get0DColor( color[0], color[1], color[2] );
1576 elem0dColor.setRgbF( color[0], color[1], color[2] );
1577 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1578 // balls: color, size
1579 anActor->GetBallColor( color[0], color[1], color[2] );
1580 ballColor.setRgbF( color[0], color[1], color[2] );
1581 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1582 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1584 anActor->GetOutlineColor( color[0], color[1], color[2] );
1585 outlineColor.setRgbF( color[0], color[1], color[2] );
1586 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1587 // orientation vectors: color, scale, 3d flag
1588 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1589 orientationColor.setRgbF( color[0], color[1], color[2] );
1590 orientationScale = anActor->GetFacesOrientationScale();
1591 orientation3d = anActor->GetFacesOrientation3DVectors();
1593 shrinkCoef = anActor->GetShrinkFactor();
1596 firstTime = false; // we only take properties from first object (for performance reasons)
1599 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1600 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1601 presentEntities = presentEntities | SMESH_Actor::eEdges;
1602 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1603 presentEntities = presentEntities | SMESH_Actor::eFaces;
1604 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1605 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1606 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1607 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1608 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1609 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1611 // as we know that all types of elements are present, we can exit the loop
1612 if ( presentEntities == SMESH_Actor::eAllEntity )
1616 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1617 // nodes: color, marker
1618 dlg.setNodeColor( nodeColor );
1619 if( markerType != VTK::MT_USER )
1620 dlg.setNodeMarker( markerType, markerScale );
1622 dlg.setNodeCustomMarker( markerId );
1623 // edges: color, line width
1624 dlg.setEdgeColor( edgeColor );
1625 dlg.setEdgeWidth( edgeWidth );
1626 // faces: front color, back color
1627 dlg.setFaceColor( faceColor, deltaF );
1628 // volumes: normal color, reversed color
1629 dlg.setVolumeColor( volumeColor, deltaV );
1630 // outlines: color, line width
1631 dlg.setOutlineColor( outlineColor );
1632 dlg.setOutlineWidth( outlineWidth );
1633 // 0d elements: color, size
1634 dlg.setElem0dColor( elem0dColor );
1635 dlg.setElem0dSize( elem0dSize );
1636 // balls: color, size
1637 dlg.setBallColor( ballColor );
1638 //dlg.setBallSize( ballSize );
1639 dlg.setBallScale( ballScale );
1640 // orientation: color, scale, 3d flag
1641 dlg.setOrientationColor( orientationColor );
1642 dlg.setOrientationSize( int( orientationScale * 100. ) );
1643 dlg.setOrientation3d( orientation3d );
1644 // shrink: scale factor
1645 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1646 // hide unused controls
1647 dlg.showControls( presentEntities, hasNodes );
1650 nodeColor = dlg.nodeColor();
1651 markerType = dlg.nodeMarkerType();
1652 markerScale = dlg.nodeMarkerScale();
1653 markerId = dlg.nodeMarkerId();
1654 edgeColor = dlg.edgeColor();
1655 edgeWidth = dlg.edgeWidth();
1656 faceColor = dlg.faceColor();
1657 deltaF = dlg.faceColorDelta();
1658 volumeColor = dlg.volumeColor();
1659 deltaV = dlg.volumeColorDelta();
1660 outlineColor = dlg.outlineColor();
1661 outlineWidth = dlg.outlineWidth();
1662 elem0dColor = dlg.elem0dColor();
1663 elem0dSize = dlg.elem0dSize();
1664 ballColor = dlg.ballColor();
1665 // ballSize = dlg.ballSize();
1666 ballScale = dlg.ballScale();
1667 orientationColor = dlg.orientationColor();
1668 orientationScale = dlg.orientationSize() / 100.;
1669 orientation3d = dlg.orientation3d();
1670 shrinkCoef = dlg.shrinkCoef() / 100.;
1672 // store point markers that might be changed by the user
1673 theMarkerMap = dlg.customMarkers();
1675 // set properties from dialog box to the presentations
1676 SALOME_ListIteratorOfListIO It( selected );
1677 for ( ; It.More(); It.Next() ) {
1678 Handle(SALOME_InteractiveObject) IObject = It.Value();
1679 if ( !IObject->hasEntry() ) continue;
1680 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1681 if ( !anActor ) continue;
1683 // nodes: color, marker
1684 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1685 if ( markerType != VTK::MT_USER ) {
1686 anActor->SetMarkerStd( markerType, markerScale );
1689 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1690 if ( iter != theMarkerMap.end() )
1691 anActor->SetMarkerTexture( markerId, iter->second.second );
1693 // volumes: normal color, reversed color (delta)
1694 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1695 // faces: front color, back color (delta)
1696 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1697 // edges: color, width
1698 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1699 anActor->SetLineWidth( edgeWidth );
1701 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1702 anActor->SetOutlineWidth( outlineWidth );
1703 // 0D elements: color, size
1704 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1705 anActor->Set0DSize( elem0dSize );
1706 // balls: color, size
1707 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1708 // anActor->SetBallSize( ballSize );
1709 anActor->SetBallScale( ballScale );
1710 // orientation: color, scale, 3d flag
1711 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1712 anActor->SetFacesOrientationScale( orientationScale );
1713 anActor->SetFacesOrientation3DVectors( orientation3d );
1715 anActor->SetShrinkFactor( shrinkCoef );
1717 // for groups, set also proper color
1718 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1719 if ( !aGroupObject->_is_nil() ) {
1720 SMESH::ElementType anElementType = aGroupObject->GetType();
1722 switch( anElementType ) {
1724 aColor = nodeColor; break;
1726 aColor = edgeColor; break;
1728 aColor = faceColor; break;
1730 aColor = volumeColor; break;
1732 aColor = elem0dColor; break;
1734 aColor = ballColor; break;
1738 if ( aColor.isValid() ) {
1739 SALOMEDS::Color aGroupColor;
1740 aGroupColor.R = aColor.redF();
1741 aGroupColor.G = aColor.greenF();
1742 aGroupColor.B = aColor.blueF();
1743 aGroupObject->SetColor( aGroupColor );
1745 } // if ( !aGroupObject->_is_nil() )
1746 } // for ( ; It.More(); It.Next() )
1747 SMESH::RepaintCurrentView();
1748 } // if ( dlg.exec() )
1750 } // case SMESHOp::OpProperties:
1751 } // switch(theCommandID)
1752 SUIT_OverrideCursor wc;
1753 SALOME_ListIteratorOfListIO It( selected );
1754 for( ; It.More(); It.Next()){
1755 Handle(SALOME_InteractiveObject) IObject = It.Value();
1756 if(IObject->hasEntry()){
1757 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1758 switch(theCommandID){
1759 case SMESHOp::OpDMWireframe:
1760 anActor->SetRepresentation(SMESH_Actor::eEdge);
1762 case SMESHOp::OpDMShading:
1763 anActor->SetRepresentation(SMESH_Actor::eSurface);
1765 case SMESHOp::OpDMShrink:
1766 if(anActor->IsShrunk())
1767 anActor->UnShrink();
1769 anActor->SetShrink();
1771 case SMESHOp::OpDMNodes:
1772 anActor->SetRepresentation(SMESH_Actor::ePoint);
1774 case SMESHOp::OpRepresentationLines:
1775 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1776 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1778 case SMESHOp::OpRepresentationArcs:
1779 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1780 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1786 SMESH::RepaintCurrentView();
1790 int ActionToControl( int theID, bool theReversed )
1792 NCollection_DoubleMap<int,int> ActionControl;
1793 ActionControl.Bind( 0, SMESH_Actor::eNone );
1794 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1795 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1796 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1797 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1798 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1799 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1800 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1801 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1802 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1803 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1804 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1805 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1806 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1807 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1808 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1809 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1810 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1811 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1812 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1813 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1814 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1815 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1816 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1817 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1818 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1819 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1820 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1821 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1824 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1825 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1828 void Control( int theCommandID )
1830 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1831 _PTR(Study) aStudy = SMESH::getStudy();
1833 SALOME_ListIO selected;
1834 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1835 aSel->selectedObjects( selected );
1837 if ( !selected.IsEmpty() ) {
1838 SALOME_ListIteratorOfListIO It(selected);
1839 for ( ; It.More(); It.Next())
1841 Handle(SALOME_InteractiveObject) anIO = It.Value();
1842 if ( !anIO.IsNull() ) {
1843 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1845 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1846 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1847 if ( !anIDSrc->_is_nil() ) {
1848 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1849 if (( !anActor && selected.Extent() == 1 ) &&
1850 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1852 anActor->SetControlMode( aControl );
1853 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1854 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1858 if ( anActor->GetControlMode() != aControl )
1859 anActor->SetControlMode( aControl );
1860 QString functorName = functorToString( anActor->GetFunctor() );
1861 smIdType anEntitiesCount = anActor->GetNumberControlEntities();
1862 if (anEntitiesCount >= 0)
1863 functorName = functorName + ": " + QString::number(anEntitiesCount);
1864 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1865 SMESH::RepaintCurrentView();
1866 #ifndef DISABLE_PLOT2DVIEWER
1867 if ( anActor->GetPlot2Histogram() ) {
1868 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1869 QString aHistogramName("%1 : %2");
1870 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1871 aHistogram->setName( aHistogramName );
1872 aHistogram->setHorTitle( functorName );
1873 SMESH::ProcessIn2DViewers( anActor );
1885 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1886 SMESH::MeshObjectType theType,
1887 const QString theInTypeName,
1888 QString & theOutTypeName)
1890 SMESH_TypeFilter aTypeFilter( theType );
1892 if ( !theIO.IsNull() )
1894 entry = theIO->getEntry();
1895 LightApp_DataOwner owner( entry );
1896 if ( aTypeFilter.isOk( &owner )) {
1897 theOutTypeName = theInTypeName;
1905 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1907 _PTR(Study) aStudy = SMESH::getStudy();
1908 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1910 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1911 CORBA::String_var anID = aSComp->GetID().c_str();
1912 if ( !strcmp(anID.in(),theIO->getEntry()) )
1918 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1919 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1920 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1921 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1922 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1930 // QString CheckHomogeneousSelection()
1932 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1933 // SALOME_ListIO selected;
1935 // aSel->selectedObjects( selected );
1937 // QString RefType = CheckTypeObject(selected.First());
1938 // SALOME_ListIteratorOfListIO It(selected);
1939 // for ( ; It.More(); It.Next())
1941 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1942 // QString Type = CheckTypeObject(IObject);
1943 // if ( Type.compare(RefType) != 0 )
1944 // return "Heterogeneous Selection";
1950 uint randomize( uint size )
1952 static bool initialized = false;
1953 if ( !initialized ) {
1954 qsrand( QDateTime::currentDateTime().toTime_t() );
1958 v = uint( (double)( v ) / RAND_MAX * size );
1959 v = qMax( uint(0), qMin ( v, size-1 ) );
1965 void SMESHGUI::OnEditDelete()
1967 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1968 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1969 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1971 _PTR(Study) aStudy = SMESH::getStudy();
1972 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1973 _PTR(GenericAttribute) anAttr;
1974 _PTR(AttributeIOR) anIOR;
1976 const int objectCountLimit = 30; // PAL23599
1977 int objectCount = 0;
1979 QString aParentComponent = QString::null;
1981 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1983 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1984 if ( anIO.IsNull() ) continue;
1986 QString father = "unknown", name;
1988 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1990 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1991 // check if object is reference
1992 _PTR(SObject) aRefSObj;
1993 if ( aSO->ReferencedObject( aRefSObj ) ) {
1994 name = QString::fromStdString ( aRefSObj->GetName() );
1995 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1998 name = anIO->getName();
2001 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
2002 aNameList.append("\n - ");
2003 aNameList.append( name );
2006 if( aParentComponent.isNull() )
2007 aParentComponent = father;
2008 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2009 aParentComponent = "";
2011 if ( objectCount >= objectCountLimit )
2012 aNameList.append("\n - ...");
2014 if ( objectCount == 0 )
2015 return; // No Valid Objects Selected
2017 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2018 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2019 QObject::tr("ERR_ERROR"),
2020 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2023 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2024 if (SUIT_MessageBox::warning
2025 (SMESHGUI::desktop(),
2026 QObject::tr("SMESH_WRN_WARNING"),
2027 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2028 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2029 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2032 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2034 // Put one level of sub-objects of the selected SO's into a list
2035 // in order to get objects inside folders like "Assigned Algorithms"
2036 std::list< _PTR(SObject) > listSO;
2037 SALOME_ListIteratorOfListIO It(selected);
2038 for( ; It.More(); It.Next()) // loop on selected IO's
2040 Handle(SALOME_InteractiveObject) IObject = It.Value();
2041 if(IObject->hasEntry()) {
2042 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2044 // disable removal of "SMESH" component object
2045 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2047 if ( engineIOR() == anIOR->Value().c_str() )
2050 //Check the referenced object
2051 _PTR(SObject) aRefSObject;
2052 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2053 aSO = aRefSObject; // Delete main Object instead of reference
2055 listSO.push_back( aSO );
2057 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2058 for (it->InitEx(false); it->More(); it->Next())
2059 listSO.push_back( it->Value() );
2062 // Check if none of objects to delete is referred from outside
2063 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2064 std::vector< _PTR(SObject) > subSO;
2065 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2067 _PTR(SObject) SO = *ritSO;
2068 if ( !SO ) continue;
2070 int nbChildren = SO->GetLastChildTag();
2072 subSO.reserve( 1 + nbChildren );
2073 subSO.push_back( SO );
2074 if ( nbChildren > 0 )
2076 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2077 for ( it->InitEx( true ); it->More(); it->Next() )
2078 subSO.push_back( it->Value() );
2080 for ( size_t i = 0; i < subSO.size(); ++i )
2082 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2083 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2084 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2085 std::string type = aComponent->ComponentDataType();
2086 if ( type != "SMESH" )
2088 SUIT_MessageBox::warning( anApp->desktop(),
2089 QObject::tr("WRN_WARNING"),
2090 QObject::tr("DEP_OBJECT") );
2091 return; // outside SMESH, there is an object depending on a SMESH object
2097 // Treat SO's in the list starting from the back
2098 aStudyBuilder->NewCommand(); // There is a transaction
2099 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2101 _PTR(SObject) SO = *ritSO;
2102 if ( !SO ) continue;
2103 std::string anEntry = SO->GetID();
2105 /** Erase graphical object and remove all its data **/
2106 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2107 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2109 /** Remove an object from data structures **/
2110 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2111 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2112 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2113 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2114 aMesh->RemoveGroup( aGroup );
2116 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2117 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2118 aMesh->RemoveSubMesh( aSubMesh );
2121 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2122 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2123 QString objType = CheckTypeObject(IObject);
2124 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2125 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2126 aStudyBuilder->RemoveObjectWithChildren( SO );
2128 else {// default action: remove SObject from the study
2129 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2130 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2132 aStudyBuilder->RemoveObjectWithChildren( SO );
2136 } /* listSO back loop */
2138 aStudyBuilder->CommitCommand();
2140 /* Clear any previous selection */
2142 aSel->setSelectedObjects( l1 );
2144 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2148 SMESHGUI_EXPORT CAM_Module* createModule()
2150 return new SMESHGUI();
2153 SMESHGUI_EXPORT char* getModuleVersion() {
2154 return (char*)SMESH_VERSION_STR;
2158 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2160 //=============================================================================
2164 //=============================================================================
2165 SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
2167 if ( CORBA::is_nil( myComponentSMESH ) )
2169 CORBA::Boolean anIsEmbeddedMode;
2170 SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
2171 if( dynamic_cast<SALOME_NamingService *>(ns) )
2172 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2175 Engines::EngineComponent_var comp = RetrieveSMESHInstance();
2176 myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
2179 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2181 // 0019923: EDF 765 SMESH : default values of hypothesis
2182 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2183 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2184 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2185 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2186 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2188 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2189 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2190 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2192 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2193 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2197 myActiveDialogBox = 0;
2198 myFilterLibraryDlg = 0;
2202 myEventCallbackCommand = vtkCallbackCommand::New();
2203 myEventCallbackCommand->Delete();
2204 myEventCallbackCommand->SetClientData( this );
2205 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2208 /* load resources for all available meshers */
2209 SMESH::InitAvailableHypotheses();
2212 //=============================================================================
2216 //=============================================================================
2217 SMESHGUI::~SMESHGUI()
2221 //=============================================================================
2225 //=============================================================================
2226 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2228 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2230 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2235 //=============================================================================
2239 //=============================================================================
2240 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2242 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2246 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2247 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2248 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2249 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2250 return autoUpdate && !exceeded;
2253 //=============================================================================
2257 //=============================================================================
2258 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2259 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2261 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2265 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2266 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2267 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2269 SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
2270 long nbOdElems = info[SMDSEntity_0D];
2271 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2272 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2273 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2274 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2275 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2276 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2277 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2278 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2279 info[SMDSEntity_Polyhedra] +
2280 info[SMDSEntity_Hexagonal_Prism];
2281 long nbBalls = info[SMDSEntity_Ball];
2283 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2284 *nbElements = requestedSize;
2286 *entities = SMESH_Actor::eAllEntity;
2289 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2291 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2293 if ( incrementalLimit ) {
2296 if ( nbOdElems > 0 ) {
2297 if ( total + nbOdElems > updateLimit ) {
2298 *entities = *entities & ~SMESH_Actor::e0DElements;
2299 *hidden = *hidden | SMESH_Actor::e0DElements;
2306 if ( nbEdges > 0 ) {
2307 if ( total + nbEdges > updateLimit ) {
2308 *entities = *entities & ~SMESH_Actor::eEdges;
2309 *hidden = *hidden | SMESH_Actor::eEdges;
2316 if ( nbFaces > 0 ) {
2317 if ( total + nbFaces > updateLimit ) {
2318 *entities = *entities & ~SMESH_Actor::eFaces;
2319 *hidden = *hidden | SMESH_Actor::eFaces;
2326 if ( nbVolumes > 0 ) {
2327 if ( total + nbVolumes > updateLimit ) {
2328 *entities = *entities & ~SMESH_Actor::eVolumes;
2329 *hidden = *hidden | SMESH_Actor::eVolumes;
2336 if ( nbBalls > 0 ) {
2337 if ( total + nbBalls > updateLimit ) {
2338 *entities = *entities & ~SMESH_Actor::eBallElem;
2339 *hidden = *hidden | SMESH_Actor::eBallElem;
2347 return autoUpdate && !exceeded;
2350 //=============================================================================
2354 //=============================================================================
2355 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2357 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2360 //=============================================================================
2364 //=============================================================================
2365 SMESHGUI* SMESHGUI::GetSMESHGUI()
2367 SMESHGUI* smeshMod = 0;
2368 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2371 CAM_Module* module = app->module( "Mesh" );
2372 smeshMod = dynamic_cast<SMESHGUI*>( module );
2380 Standard_EXPORT SMESHGUI* GetComponentGUI()
2382 return SMESHGUI::GetSMESHGUI();
2386 //=============================================================================
2390 //=============================================================================
2391 void SMESHGUI::SetState(int aState)
2396 //=============================================================================
2400 //=============================================================================
2401 void SMESHGUI::ResetState()
2406 //=============================================================================
2410 //=============================================================================
2411 void SMESHGUI::EmitSignalDeactivateDialog()
2413 emit SignalDeactivateActiveDialog();
2416 //=============================================================================
2420 //=============================================================================
2421 void SMESHGUI::EmitSignalStudyFrameChanged()
2423 emit SignalStudyFrameChanged();
2426 //=============================================================================
2430 //=============================================================================
2431 void SMESHGUI::EmitSignalCloseAllDialogs()
2433 emit SignalCloseAllDialogs();
2436 //=============================================================================
2440 //=============================================================================
2441 void SMESHGUI::EmitSignalVisibilityChanged()
2443 emit SignalVisibilityChanged();
2446 //=============================================================================
2450 //=============================================================================
2451 void SMESHGUI::EmitSignalCloseView()
2453 emit SignalCloseView();
2456 //=============================================================================
2460 //=============================================================================
2461 void SMESHGUI::EmitSignalActivatedViewManager()
2463 emit SignalActivatedViewManager();
2466 //=============================================================================
2470 //=============================================================================
2471 QDialog *SMESHGUI::GetActiveDialogBox()
2473 return myActiveDialogBox;
2476 //=============================================================================
2480 //=============================================================================
2481 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2483 myActiveDialogBox = (QDialog *) aDlg;
2487 //=============================================================================
2491 //=============================================================================
2492 SUIT_Desktop* SMESHGUI::desktop()
2494 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2496 return app->desktop();
2501 //=============================================================================
2505 //=============================================================================
2506 SalomeApp_Study* SMESHGUI::activeStudy()
2508 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2510 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2515 //=============================================================================
2519 //=============================================================================
2520 void SMESHGUI::Modified( bool theIsUpdateActions )
2522 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2523 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2524 appStudy->Modified();
2525 if( theIsUpdateActions )
2526 app->updateActions();
2531 //=============================================================================
2535 //=============================================================================
2536 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2538 /* Here the position is on the bottom right corner - 10 */
2539 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2541 SUIT_Desktop *PP = desktop();
2542 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2543 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2548 * \brief Verifies whether study of operation is locked
2549 * \param theMess - specifies whether message box must be shown if study is locked
2550 * \return State of study.
2552 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2553 * is locked when corresponding message box appears
2555 bool SMESHGUI::isStudyLocked( bool theMessage )
2557 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2560 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2561 QObject::tr( "WRN_WARNING" ),
2562 QObject::tr( "WRN_STUDY_LOCKED" ) );
2568 //=============================================================================
2572 //=============================================================================
2573 bool SMESHGUI::OnGUIEvent( int theCommandID )
2575 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2579 SUIT_ResourceMgr* mgr = resourceMgr();
2583 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2584 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2586 //QAction* act = action( theCommandID );
2588 switch (theCommandID) {
2589 case SMESHOp::OpDelete:
2590 if(isStudyLocked()) break;
2593 case SMESHOp::OpImportDAT:
2594 case SMESHOp::OpImportUNV:
2595 case SMESHOp::OpImportMED:
2596 case SMESHOp::OpImportSTL:
2597 case SMESHOp::OpImportCGNS:
2598 case SMESHOp::OpImportSAUV:
2599 case SMESHOp::OpImportGMF:
2600 case SMESHOp::OpPopupImportDAT:
2601 case SMESHOp::OpPopupImportUNV:
2602 case SMESHOp::OpPopupImportMED:
2603 case SMESHOp::OpPopupImportSTL:
2604 case SMESHOp::OpPopupImportCGNS:
2605 case SMESHOp::OpPopupImportSAUV:
2606 case SMESHOp::OpPopupImportGMF:
2608 if(isStudyLocked()) break;
2609 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2613 case SMESHOp::OpFileInformation:
2615 SALOME_ListIO selected;
2616 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2618 aSel->selectedObjects( selected );
2619 if( selected.Extent() )
2621 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2622 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2623 if ( !aMesh->_is_nil() )
2625 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2631 case SMESHOp::OpExportDAT:
2632 case SMESHOp::OpExportMED:
2633 case SMESHOp::OpExportUNV:
2634 case SMESHOp::OpExportSTL:
2635 case SMESHOp::OpExportCGNS:
2636 case SMESHOp::OpExportSAUV:
2637 case SMESHOp::OpExportGMF:
2638 case SMESHOp::OpPopupExportDAT:
2639 case SMESHOp::OpPopupExportMED:
2640 case SMESHOp::OpPopupExportUNV:
2641 case SMESHOp::OpPopupExportSTL:
2642 case SMESHOp::OpPopupExportCGNS:
2643 case SMESHOp::OpPopupExportSAUV:
2644 case SMESHOp::OpPopupExportGMF:
2646 ::ExportMeshToFile(theCommandID);
2650 case SMESHOp::OpReset: // SCALAR BAR
2652 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2653 SALOME_ListIO selected;
2655 aSel->selectedObjects( selected );
2657 SALOME_ListIteratorOfListIO it(selected);
2658 for( ; it.More(); it.Next()) {
2659 Handle(SALOME_InteractiveObject) anIO = it.Value();
2660 if( anIO->hasEntry() ) {
2661 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2662 anActor->SetControlMode( SMESH_Actor::eNone );
2663 #ifndef DISABLE_PLOT2DVIEWER
2664 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2666 anActor->UpdateFilter();
2670 SMESH::UpdateView();
2673 case SMESHOp::OpScalarBarProperties:
2675 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2678 case SMESHOp::OpShowScalarBar:
2680 // show/hide scalar bar
2681 ::ShowElement(theCommandID);
2684 case SMESHOp::OpSaveDistribution:
2686 // dump control distribution data to the text file
2687 ::SaveDistribution();
2691 case SMESHOp::OpShowDistribution:
2693 // show/hide distribution
2694 ::ShowElement(theCommandID);
2698 #ifndef DISABLE_PLOT2DVIEWER
2699 case SMESHOp::OpPlotDistribution:
2701 // plot distribution
2702 ::PlotDistribution();
2708 case SMESHOp::OpAutoColor:
2712 case SMESHOp::OpDisableAutoColor:
2713 ::DisableAutoColor();
2716 case SMESHOp::OpClipping:
2717 case SMESHOp::OpTransparency:
2718 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2721 case SMESHOp::OpDMWireframe:
2722 case SMESHOp::OpDMShading:
2723 case SMESHOp::OpDMNodes:
2724 case SMESHOp::OpDMShrink:
2725 ::SetDisplayMode(theCommandID, myMarkerMap);
2728 //2D quadratic representation
2729 case SMESHOp::OpRepresentationLines:
2730 case SMESHOp::OpRepresentationArcs:
2731 ::SetDisplayMode(theCommandID, myMarkerMap);
2735 case SMESHOp::OpDE0DElements:
2736 case SMESHOp::OpDEEdges:
2737 case SMESHOp::OpDEFaces:
2738 case SMESHOp::OpDEVolumes:
2739 case SMESHOp::OpDEBalls:
2740 case SMESHOp::OpDEAllEntity:
2741 ::SetDisplayEntity(theCommandID);
2744 // Choose entities to be displayed
2745 case SMESHOp::OpDEChoose:
2747 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2751 case SMESHOp::OpOrientationOnFaces:
2753 SUIT_OverrideCursor wc;
2754 LightApp_SelectionMgr* mgr = selectionMgr();
2755 SALOME_ListIO selected; mgr->selectedObjects( selected );
2757 SALOME_ListIteratorOfListIO it(selected);
2758 for( ; it.More(); it.Next()) {
2759 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2760 if(anIObject->hasEntry()) {
2761 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2762 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2769 case SMESHOp::OpUpdate:
2771 if(isStudyLocked()) break;
2772 SUIT_OverrideCursor wc;
2775 SMESH::UpdateView();
2777 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2778 SMESH::OnVisuException();
2780 catch (...) { // PAL16774 (Crash after display of many groups)
2781 SMESH::OnVisuException();
2785 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2786 aSel->selectedObjects( l );
2787 aSel->setSelectedObjects( l );
2791 case SMESHOp::OpHide:
2792 case SMESHOp::OpShow:
2793 case SMESHOp::OpShowOnly:
2795 SUIT_OverrideCursor wc;
2796 SMESH::EDisplaing anAction;
2797 switch (theCommandID) {
2798 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2799 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2800 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2803 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2804 SALOME_ListIO sel_objects, to_process;
2806 aSel->selectedObjects( sel_objects );
2808 if ( theCommandID==SMESHOp::OpShowOnly )
2810 //MESSAGE("anAction = SMESH::eDisplayOnly");
2811 startOperation( myEraseAll );
2814 extractContainers( sel_objects, to_process );
2819 SALOME_ListIteratorOfListIO It( to_process );
2820 for ( ; It.More(); It.Next())
2822 Handle(SALOME_InteractiveObject) IOS = It.Value();
2823 if ( IOS->hasEntry() )
2825 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2826 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2827 break; // PAL16774 (Crash after display of many groups)
2829 if (anAction == SMESH::eDisplayOnly)
2830 anAction = SMESH::eDisplay;
2835 // PAL13338 + PAL15161 -->
2836 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2837 SMESH::UpdateView();
2838 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2840 // PAL13338 + PAL15161 <--
2842 catch (...) { // PAL16774 (Crash after display of many groups)
2843 SMESH::OnVisuException();
2846 if (anAction == SMESH::eErase) {
2848 aSel->setSelectedObjects( l1 );
2851 aSel->setSelectedObjects( to_process );
2853 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2854 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2855 vtkwnd->GetRenderer()->AdjustActors();
2860 case SMESHOp::OpNode:
2862 if(isStudyLocked()) break;
2865 EmitSignalDeactivateDialog();
2867 ( new SMESHGUI_NodesDlg( this ) )->show();
2870 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2875 case SMESHOp::OpEditMeshOrSubMesh:
2876 case SMESHOp::OpEditMesh:
2877 case SMESHOp::OpEditSubMesh:
2878 case SMESHOp::OpMeshOrder:
2879 case SMESHOp::OpCreateSubMesh:
2880 if ( warnOnGeomModif() )
2881 break; // action forbidden as geometry modified
2883 case SMESHOp::OpCreateMesh:
2884 case SMESHOp::OpCompute:
2885 case SMESHOp::OpComputeSubMesh:
2886 case SMESHOp::OpPreCompute:
2887 case SMESHOp::OpEvaluate:
2888 case SMESHOp::OpShowErrors:
2889 startOperation( theCommandID );
2891 case SMESHOp::OpRecompute:
2893 if ( isStudyLocked() )
2895 SALOME_ListIO selected;
2896 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2897 sel->selectedObjects( selected );
2898 if ( selected.Extent() == 1 ) {
2899 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2900 if ( !aMesh->_is_nil() )
2902 startOperation( SMESHOp::OpCompute );
2906 case SMESHOp::OpCopyMesh:
2908 if (isStudyLocked()) break;
2909 EmitSignalDeactivateDialog();
2910 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2913 case SMESHOp::OpBuildCompoundMesh:
2915 if (isStudyLocked()) break;
2916 EmitSignalDeactivateDialog();
2917 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2921 case SMESHOp::OpDiagonalInversion:
2922 case SMESHOp::OpUnionOfTwoTriangle:
2926 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2930 if ( isStudyLocked() )
2932 if ( warnOnGeomModif() )
2933 break; // action forbidden as geometry modified
2935 /*Standard_Boolean aRes;
2936 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2937 if ( aMesh->_is_nil() )
2939 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2940 tr( "SMESH_BAD_SELECTION" ) );
2944 EmitSignalDeactivateDialog();
2945 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2946 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2948 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2951 case SMESHOp::OpOrientation:
2952 case SMESHOp::OpUnionOfTriangles:
2953 case SMESHOp::OpCuttingOfQuadrangles:
2954 case SMESHOp::OpSplitVolumes:
2958 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2962 if ( isStudyLocked() )
2964 if ( warnOnGeomModif() )
2965 break; // action forbidden as geometry modified
2967 EmitSignalDeactivateDialog();
2968 SMESHGUI_MultiEditDlg* aDlg = NULL;
2969 if ( theCommandID == SMESHOp::OpOrientation )
2970 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2971 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2972 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2973 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2974 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2976 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2981 case SMESHOp::OpSmoothing:
2983 if(isStudyLocked()) break;
2984 if ( warnOnGeomModif() )
2985 break; // action forbidden as geometry modified
2987 EmitSignalDeactivateDialog();
2988 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2991 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2995 case SMESHOp::OpExtrusion:
2997 if (isStudyLocked()) break;
2998 if ( warnOnGeomModif() )
2999 break; // action forbidden as geometry modified
3001 EmitSignalDeactivateDialog();
3002 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
3004 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3008 case SMESHOp::OpExtrusionAlongAPath:
3010 if (isStudyLocked()) break;
3011 if ( warnOnGeomModif() )
3012 break; // action forbidden as geometry modified
3014 EmitSignalDeactivateDialog();
3015 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3017 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3021 case SMESHOp::OpRevolution:
3023 if(isStudyLocked()) break;
3024 if ( warnOnGeomModif() )
3025 break; // action forbidden as geometry modified
3027 EmitSignalDeactivateDialog();
3028 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3031 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3035 case SMESHOp::OpPatternMapping:
3037 if ( isStudyLocked() )
3039 if ( warnOnGeomModif() )
3040 break; // action forbidden as geometry modified
3043 EmitSignalDeactivateDialog();
3044 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3047 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3051 // Adaptation - begin
3052 #ifndef DISABLE_MG_ADAPT
3053 case SMESHOp::OpMGAdapt:
3055 if ( isStudyLocked() )
3057 EmitSignalDeactivateDialog();
3059 SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
3060 bool isCreation = false;
3061 ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
3066 case SMESHOp::OpSplitBiQuadratic:
3067 case SMESHOp::OpConvertMeshToQuadratic:
3068 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3069 case SMESHOp::OpReorientFaces:
3070 case SMESHOp::OpCreateGeometryGroup:
3072 if ( warnOnGeomModif() )
3073 break; // action forbidden as geometry modified
3074 startOperation( theCommandID );
3077 case SMESHOp::OpCreateGroup:
3081 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3085 if(isStudyLocked()) break;
3086 if ( warnOnGeomModif() )
3087 break; // action forbidden as geometry modified
3088 EmitSignalDeactivateDialog();
3089 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3091 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3092 SALOME_ListIO selected;
3094 aSel->selectedObjects( selected );
3096 int nbSel = selected.Extent();
3098 // check if mesh is selected
3099 aMesh = SMESH::GetMeshByIO( selected.First() );
3101 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3106 case SMESHOp::OpConstructGroup:
3110 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3114 if(isStudyLocked()) break;
3115 if ( warnOnGeomModif() )
3116 break; // action forbidden as geometry modified
3117 EmitSignalDeactivateDialog();
3119 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3120 SALOME_ListIO selected;
3122 aSel->selectedObjects( selected );
3124 int nbSel = selected.Extent();
3126 // check if submesh is selected
3127 Handle(SALOME_InteractiveObject) IObject = selected.First();
3128 if (IObject->hasEntry()) {
3129 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3131 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3132 if (!aSubMesh->_is_nil()) {
3134 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3135 // get submesh elements list by types
3136 SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3137 SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3138 SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3139 SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3140 // create group for each type o elements
3141 QString aName = IObject->getName();
3142 QStringList anEntryList;
3143 if (aNodes->length() > 0) {
3144 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3145 aGroup->Add(aNodes.inout());
3146 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3147 anEntryList.append( aSObject->GetID().c_str() );
3149 if (aEdges->length() > 0) {
3150 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3151 aGroup->Add(aEdges.inout());
3152 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3153 anEntryList.append( aSObject->GetID().c_str() );
3155 if (aFaces->length() > 0) {
3156 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3157 aGroup->Add(aFaces.inout());
3158 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3159 anEntryList.append( aSObject->GetID().c_str() );
3161 if (aVolumes->length() > 0) {
3162 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3163 aGroup->Add(aVolumes.inout());
3164 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3165 anEntryList.append( aSObject->GetID().c_str() );
3168 anApp->browseObjects( anEntryList );
3170 catch(const SALOME::SALOME_Exception & S_ex){
3171 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3178 SUIT_MessageBox::warning(desktop(),
3179 tr("SMESH_WRN_WARNING"),
3180 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3185 case SMESHOp::OpEditGroup:
3189 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3193 if(isStudyLocked()) break;
3194 if ( warnOnGeomModif() )
3195 break; // action forbidden as geometry modified
3196 EmitSignalDeactivateDialog();
3198 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3199 SALOME_ListIO selected;
3201 aSel->selectedObjects( selected );
3203 SALOME_ListIteratorOfListIO It (selected);
3204 int nbSelectedGroups = 0;
3205 for ( ; It.More(); It.Next() )
3207 SMESH::SMESH_GroupBase_var aGroup =
3208 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3209 if (!aGroup->_is_nil()) {
3211 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3215 if (nbSelectedGroups == 0)
3217 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3223 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3225 if(isStudyLocked()) break;
3226 if (myState == 800) {
3227 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3228 if (aDlg) aDlg->onAdd();
3233 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3235 if(isStudyLocked()) break;
3236 if (myState == 800) {
3237 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3238 if (aDlg) aDlg->onRemove();
3243 case SMESHOp::OpEditGeomGroupAsGroup:
3247 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3251 if(isStudyLocked()) break;
3252 EmitSignalDeactivateDialog();
3254 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3255 SALOME_ListIO selected;
3257 aSel->selectedObjects( selected );
3259 SALOME_ListIteratorOfListIO It (selected);
3260 for ( ; It.More(); It.Next() )
3262 SMESH::SMESH_GroupOnGeom_var aGroup =
3263 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3264 if (!aGroup->_is_nil()) {
3265 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3270 SMESH::SMESH_GroupOnFilter_var aGroup =
3271 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3272 if (!aGroup->_is_nil()) {
3273 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3281 case SMESHOp::OpUnionGroups:
3282 case SMESHOp::OpIntersectGroups:
3283 case SMESHOp::OpCutGroups:
3287 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3291 if ( isStudyLocked() )
3293 if ( warnOnGeomModif() )
3294 break; // action forbidden as geometry modified
3296 EmitSignalDeactivateDialog();
3298 SMESHGUI_GroupOpDlg* aDlg = 0;
3299 if ( theCommandID == SMESHOp::OpUnionGroups )
3300 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3301 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3302 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3304 aDlg = new SMESHGUI_CutGroupsDlg( this );
3311 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3313 if ( isStudyLocked() )
3315 if ( warnOnGeomModif() )
3316 break; // action forbidden as geometry modified
3318 EmitSignalDeactivateDialog();
3319 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3325 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3327 if ( isStudyLocked() )
3329 if ( warnOnGeomModif() )
3330 break; // action forbidden as geometry modified
3332 EmitSignalDeactivateDialog();
3333 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3339 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3343 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3347 if ( isStudyLocked() )
3350 EmitSignalDeactivateDialog();
3352 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3356 case SMESHOp::OpMeshInformation:
3357 case SMESHOp::OpWhatIs:
3359 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3360 EmitSignalDeactivateDialog();
3361 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3362 SALOME_ListIO selected;
3364 aSel->selectedObjects( selected );
3366 if ( selected.Extent() > 1 ) { // a dlg for each IO
3367 SALOME_ListIteratorOfListIO It( selected );
3368 for ( ; It.More(); It.Next() ) {
3369 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3370 dlg->showInfo( It.Value() );
3375 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3381 case SMESHOp::OpFindElementByPoint:
3383 startOperation( theCommandID );
3387 case SMESHOp::OpEditHypothesis:
3389 if(isStudyLocked()) break;
3390 if ( warnOnGeomModif() )
3391 break; // action forbidden as geometry modified
3393 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3394 SALOME_ListIO selected;
3396 aSel->selectedObjects( selected );
3398 int nbSel = selected.Extent();
3401 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3402 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3404 if ( !aHypothesis->_is_nil() )
3406 SMESHGUI_GenericHypothesisCreator* aCreator =
3407 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3410 // set geometry of mesh and sub-mesh to aCreator
3411 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3412 if ( selected.Extent() == 1 )
3414 QString subGeomID, meshGeomID;
3415 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3416 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3418 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3419 aCreator->setShapeEntry( subGeomID );
3420 aCreator->setMainShapeEntry( meshGeomID );
3424 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3434 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3436 if(isStudyLocked()) break;
3437 if ( warnOnGeomModif() )
3438 break; // action forbidden as geometry modified
3439 SUIT_OverrideCursor wc;
3441 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3442 SALOME_ListIO selected;
3444 aSel->selectedObjects( selected, QString::null, false );
3446 SALOME_ListIteratorOfListIO It(selected);
3447 for (int i = 0; It.More(); It.Next(), i++) {
3448 Handle(SALOME_InteractiveObject) IObject = It.Value();
3449 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3452 aSel->setSelectedObjects( l1 );
3457 case SMESHOp::OpElem0D:
3458 case SMESHOp::OpBall:
3459 case SMESHOp::OpEdge:
3460 case SMESHOp::OpTriangle:
3461 case SMESHOp::OpQuadrangle:
3462 case SMESHOp::OpPolygon:
3463 case SMESHOp::OpTetrahedron:
3464 case SMESHOp::OpHexahedron:
3465 case SMESHOp::OpPentahedron:
3466 case SMESHOp::OpPyramid:
3467 case SMESHOp::OpHexagonalPrism:
3469 if(isStudyLocked()) break;
3470 if ( warnOnGeomModif() )
3471 break; // action forbidden as geometry modified
3473 EmitSignalDeactivateDialog();
3474 SMDSAbs_EntityType type = SMDSEntity_Edge;
3475 switch (theCommandID) {
3476 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3477 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3478 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3479 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3480 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3481 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3482 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3483 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3484 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3485 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3488 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3491 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3495 case SMESHOp::OpPolyhedron:
3497 if(isStudyLocked()) break;
3498 if ( warnOnGeomModif() )
3499 break; // action forbidden as geometry modified
3501 EmitSignalDeactivateDialog();
3502 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3505 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3509 case SMESHOp::OpQuadraticEdge:
3510 case SMESHOp::OpQuadraticTriangle:
3511 case SMESHOp::OpBiQuadraticTriangle:
3512 case SMESHOp::OpQuadraticQuadrangle:
3513 case SMESHOp::OpBiQuadraticQuadrangle:
3514 case SMESHOp::OpQuadraticPolygon:
3515 case SMESHOp::OpQuadraticTetrahedron:
3516 case SMESHOp::OpQuadraticPyramid:
3517 case SMESHOp::OpQuadraticPentahedron:
3518 case SMESHOp::OpBiQuadraticPentahedron:
3519 case SMESHOp::OpQuadraticHexahedron:
3520 case SMESHOp::OpTriQuadraticHexahedron:
3522 if(isStudyLocked()) break;
3523 if ( warnOnGeomModif() )
3524 break; // action forbidden as geometry modified
3526 EmitSignalDeactivateDialog();
3527 SMDSAbs_EntityType type = SMDSEntity_Last;
3529 switch (theCommandID) {
3530 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3531 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3532 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3533 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3534 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3535 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3536 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3537 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3538 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3539 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3540 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3541 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3544 if ( type != SMDSEntity_Last )
3545 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3548 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3549 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3553 case SMESHOp::OpRemoveNodes:
3555 if(isStudyLocked()) break;
3556 if ( warnOnGeomModif() )
3557 break; // action forbidden as geometry modified
3559 EmitSignalDeactivateDialog();
3560 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3563 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3564 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3568 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3570 if(isStudyLocked()) break;
3571 if ( warnOnGeomModif() )
3572 break; // action forbidden as geometry modified
3574 EmitSignalDeactivateDialog();
3575 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3579 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3580 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3584 case SMESHOp::OpClearMesh: {
3586 if(isStudyLocked()) break;
3587 if ( warnOnGeomModif() )
3588 break; // action forbidden as geometry modified
3590 SALOME_ListIO selected;
3591 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3592 aSel->selectedObjects( selected );
3594 SUIT_OverrideCursor wc;
3595 SALOME_ListIteratorOfListIO It (selected);
3596 for ( ; It.More(); It.Next() )
3598 Handle(SALOME_InteractiveObject) IOS = It.Value();
3599 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3600 if ( aMesh->_is_nil()) continue;
3603 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3604 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3605 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3606 // hide groups and submeshes
3607 _PTR(ChildIterator) anIter =
3608 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3609 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3611 _PTR(SObject) so = anIter->Value();
3612 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3615 catch (const SALOME::SALOME_Exception& S_ex){
3617 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3621 SMESH::UpdateView();
3625 case SMESHOp::OpRemoveOrphanNodes:
3627 if(isStudyLocked()) break;
3628 if ( warnOnGeomModif() )
3629 break; // action forbidden as geometry modified
3630 SALOME_ListIO selected;
3631 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3632 aSel->selectedObjects( selected );
3633 if ( selected.Extent() == 1 ) {
3634 Handle(SALOME_InteractiveObject) anIO = selected.First();
3635 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3636 if ( !aMesh->_is_nil() ) {
3637 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3638 tr( "SMESH_WARNING" ),
3639 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3640 SUIT_MessageBox::Yes |
3641 SUIT_MessageBox::No,
3642 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3645 SUIT_OverrideCursor wc;
3646 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3647 smIdType removed = aMeshEditor->RemoveOrphanNodes();
3648 SUIT_MessageBox::information(SMESHGUI::desktop(),
3649 tr("SMESH_INFORMATION"),
3650 tr("NB_NODES_REMOVED").arg(removed));
3651 if ( removed > 0 ) {
3652 SMESH::UpdateView();
3653 SMESHGUI::Modified();
3656 catch (const SALOME::SALOME_Exception& S_ex) {
3657 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3666 case SMESHOp::OpRenumberingNodes:
3668 if(isStudyLocked()) break;
3669 if ( warnOnGeomModif() )
3670 break; // action forbidden as geometry modified
3672 EmitSignalDeactivateDialog();
3673 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3677 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3678 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3682 case SMESHOp::OpRenumberingElements:
3684 if(isStudyLocked()) break;
3685 if ( warnOnGeomModif() )
3686 break; // action forbidden as geometry modified
3688 EmitSignalDeactivateDialog();
3689 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3693 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3694 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3698 case SMESHOp::OpTranslation:
3700 if(isStudyLocked()) break;
3701 if ( warnOnGeomModif() )
3702 break; // action forbidden as geometry modified
3704 EmitSignalDeactivateDialog();
3705 ( new SMESHGUI_TranslationDlg( this ) )->show();
3708 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3709 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3713 case SMESHOp::OpRotation:
3715 if(isStudyLocked()) break;
3716 if ( warnOnGeomModif() )
3717 break; // action forbidden as geometry modified
3719 EmitSignalDeactivateDialog();
3720 ( new SMESHGUI_RotationDlg( this ) )->show();
3723 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3724 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3728 case SMESHOp::OpSymmetry:
3730 if(isStudyLocked()) break;
3731 if ( warnOnGeomModif() )
3732 break; // action forbidden as geometry modified
3734 EmitSignalDeactivateDialog();
3735 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3738 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3739 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3743 case SMESHOp::OpScale:
3745 if(isStudyLocked()) break;
3746 if ( warnOnGeomModif() )
3747 break; // action forbidden as geometry modified
3749 EmitSignalDeactivateDialog();
3750 ( new SMESHGUI_ScaleDlg( this ) )->show();
3753 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3754 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3759 case SMESHOp::OpOffset:
3761 if(isStudyLocked()) break;
3762 if ( warnOnGeomModif() )
3763 break; // action forbidden as geometry modified
3765 EmitSignalDeactivateDialog();
3766 ( new SMESHGUI_OffsetDlg( this ) )->show();
3769 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3770 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3775 case SMESHOp::OpSewing:
3777 if(isStudyLocked()) break;
3778 if ( warnOnGeomModif() )
3779 break; // action forbidden as geometry modified
3781 EmitSignalDeactivateDialog();
3782 ( new SMESHGUI_SewingDlg( this ) )->show();
3785 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3786 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3790 case SMESHOp::OpMergeNodes:
3792 if(isStudyLocked()) break;
3793 if ( warnOnGeomModif() )
3794 break; // action forbidden as geometry modified
3796 EmitSignalDeactivateDialog();
3797 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3800 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3801 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3805 case SMESHOp::OpMergeElements:
3807 if (isStudyLocked()) break;
3808 if ( warnOnGeomModif() )
3809 break; // action forbidden as geometry modified
3811 EmitSignalDeactivateDialog();
3812 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3814 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3815 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3820 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3821 if ( warnOnGeomModif() )
3822 break; // action forbidden as geometry modified
3823 startOperation( SMESHOp::OpMoveNode );
3826 case SMESHOp::OpDuplicateNodes:
3828 if(isStudyLocked()) break;
3829 if ( warnOnGeomModif() )
3830 break; // action forbidden as geometry modified
3832 EmitSignalDeactivateDialog();
3833 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3836 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3837 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3842 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3843 if ( warnOnGeomModif() )
3844 break; // action forbidden as geometry modified
3845 startOperation( SMESHOp::OpElem0DOnElemNodes );
3848 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3850 static QList<int> aTypes;
3851 if ( aTypes.isEmpty() )
3853 aTypes.append( SMESH::NODE );
3854 aTypes.append( SMESH::EDGE );
3855 aTypes.append( SMESH::FACE );
3856 aTypes.append( SMESH::VOLUME );
3858 if (!myFilterLibraryDlg)
3859 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3860 else if (myFilterLibraryDlg->isHidden())
3861 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3862 myFilterLibraryDlg->raise();
3866 case SMESHOp::OpFreeNode:
3867 case SMESHOp::OpEqualNode:
3868 case SMESHOp::OpNodeConnectivityNb:
3869 case SMESHOp::OpFreeEdge:
3870 case SMESHOp::OpFreeBorder:
3871 case SMESHOp::OpLength:
3872 case SMESHOp::OpConnection:
3873 case SMESHOp::OpEqualEdge:
3874 case SMESHOp::OpFreeFace:
3875 case SMESHOp::OpBareBorderFace:
3876 case SMESHOp::OpOverConstrainedFace:
3877 case SMESHOp::OpLength2D:
3878 case SMESHOp::OpDeflection2D:
3879 case SMESHOp::OpConnection2D:
3880 case SMESHOp::OpArea:
3881 case SMESHOp::OpTaper:
3882 case SMESHOp::OpAspectRatio:
3883 case SMESHOp::OpMinimumAngle:
3884 case SMESHOp::OpWarpingAngle:
3885 case SMESHOp::OpSkew:
3886 case SMESHOp::OpMaxElementLength2D:
3887 case SMESHOp::OpEqualFace:
3888 case SMESHOp::OpAspectRatio3D:
3889 case SMESHOp::OpVolume:
3890 case SMESHOp::OpMaxElementLength3D:
3891 case SMESHOp::OpBareBorderVolume:
3892 case SMESHOp::OpOverConstrainedVolume:
3893 case SMESHOp::OpEqualVolume:
3896 LightApp_SelectionMgr* mgr = selectionMgr();
3897 SALOME_ListIO selected; mgr->selectedObjects( selected );
3899 if( !selected.IsEmpty() ) {
3900 SUIT_OverrideCursor wc;
3901 ::Control( theCommandID );
3904 SUIT_MessageBox::warning(desktop(),
3905 tr( "SMESH_WRN_WARNING" ),
3906 tr( "SMESH_BAD_SELECTION" ) );
3910 SUIT_MessageBox::warning(desktop(),
3911 tr( "SMESH_WRN_WARNING" ),
3912 tr( "NOT_A_VTK_VIEWER" ) );
3915 case SMESHOp::OpOverallMeshQuality:
3916 OverallMeshQuality();
3918 case SMESHOp::OpNumberingNodes:
3920 SUIT_OverrideCursor wc;
3921 LightApp_SelectionMgr* mgr = selectionMgr();
3922 SALOME_ListIO selected; mgr->selectedObjects( selected );
3924 SALOME_ListIteratorOfListIO it(selected);
3925 for( ; it.More(); it.Next()) {
3926 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3927 if(anIObject->hasEntry()) {
3928 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3929 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3935 case SMESHOp::OpNumberingElements:
3937 SUIT_OverrideCursor wc;
3938 LightApp_SelectionMgr* mgr = selectionMgr();
3939 SALOME_ListIO selected; mgr->selectedObjects( selected );
3941 SALOME_ListIteratorOfListIO it(selected);
3942 for( ; it.More(); it.Next()) {
3943 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3944 if(anIObject->hasEntry())
3945 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3946 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3951 case SMESHOp::OpPropertiesLength:
3952 case SMESHOp::OpPropertiesArea:
3953 case SMESHOp::OpPropertiesVolume:
3954 case SMESHOp::OpMinimumDistance:
3955 case SMESHOp::OpBoundingBox:
3956 case SMESHOp::OpAngle:
3958 int page = SMESHGUI_MeasureDlg::MinDistance;
3959 if ( theCommandID == SMESHOp::OpBoundingBox )
3960 page = SMESHGUI_MeasureDlg::BoundingBox;
3961 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3962 page = SMESHGUI_MeasureDlg::Length;
3963 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3964 page = SMESHGUI_MeasureDlg::Area;
3965 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3966 page = SMESHGUI_MeasureDlg::Volume;
3967 else if ( theCommandID == SMESHOp::OpAngle )
3968 page = SMESHGUI_MeasureDlg::Angle;
3970 EmitSignalDeactivateDialog();
3971 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3975 case SMESHOp::OpSortChild:
3978 case SMESHOp::OpBreakLink:
3979 ::breakShaperLink();
3984 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3985 //updateObjBrowser();
3989 //=============================================================================
3993 //=============================================================================
3994 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3999 //=============================================================================
4003 //=============================================================================
4004 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4009 //=============================================================================
4013 //=============================================================================
4014 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4019 //=============================================================================
4020 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4021 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4023 //=============================================================================
4024 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4025 SUIT_ViewWindow* wnd )
4027 if(theIO->hasEntry()){
4028 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4029 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4033 //=======================================================================
4034 // function : createSMESHAction
4036 //=======================================================================
4037 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4038 const int key, const bool toggle, const QString& shortcutAction )
4041 QWidget* parent = application()->desktop();
4042 SUIT_ResourceMgr* resMgr = resourceMgr();
4044 if ( !icon_id.isEmpty() )
4045 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4047 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4048 if ( !pix.isNull() )
4049 icon = QIcon( pix );
4051 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4052 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4053 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4055 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4056 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4059 //=======================================================================
4060 // function : createPopupItem
4062 //=======================================================================
4063 void SMESHGUI::createPopupItem( const int id,
4064 const QString& clients,
4065 const QString& types,
4066 const QString& theRule,
4069 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4070 popupMgr()->insert( action( id ), pId, 0 );
4072 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4073 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4074 QString rule = "(%1) and (%2) and (%3)";
4075 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4076 if( clients.isEmpty() )
4077 rule = rule.arg( QString( "true" ) );
4079 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4080 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4083 bool cont = myRules.contains( id );
4085 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4087 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4088 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4091 //=======================================================================
4092 // function : initialize
4094 //=======================================================================
4095 void SMESHGUI::initialize( CAM_Application* app )
4097 SalomeApp_Module::initialize( app );
4099 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4101 /* Automatic Update flag */
4102 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4104 // ----- create actions --------------
4106 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4107 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4108 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4109 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4111 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4113 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4114 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4115 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4116 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4117 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4119 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4121 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4122 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4124 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4125 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4126 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4127 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4129 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4131 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4132 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4133 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4134 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4135 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4136 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4138 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4140 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4141 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4142 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4143 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4144 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4145 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4146 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4147 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4148 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4149 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4150 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4151 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4152 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4153 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4154 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4155 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4156 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4157 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4158 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4159 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4160 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4161 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4162 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4163 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4164 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4165 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4166 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4167 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4168 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4169 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4170 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4171 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4172 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4173 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4174 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4175 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4177 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4178 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4179 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4180 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4181 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4182 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4183 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4184 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4185 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4186 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4187 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4188 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4189 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4190 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4191 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4192 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4193 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4194 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4195 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4196 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4197 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4198 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4199 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4200 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4201 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4202 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4203 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4204 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4205 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4207 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4208 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4209 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4210 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4211 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4212 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4213 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4214 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4215 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4216 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4217 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4218 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4219 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4220 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4221 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4222 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4223 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4224 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4225 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4226 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4227 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4228 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4229 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4230 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4231 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4232 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4234 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4235 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4236 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4237 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4239 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4240 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4242 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4243 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4244 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4245 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4246 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4247 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4248 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4249 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4250 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4251 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4252 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4253 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4254 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4255 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4256 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4257 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4258 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4259 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4260 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4261 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4262 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4263 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4264 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4265 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4266 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4268 createSMESHAction( SMESHOp::OpReset, "RESET" );
4269 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4270 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4271 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4272 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4273 #ifndef DISABLE_PLOT2DVIEWER
4274 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4276 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4277 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4278 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4279 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4280 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4281 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4282 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4283 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4284 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4285 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4286 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4287 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4288 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4290 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4291 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4293 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4294 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4295 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4296 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4297 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4298 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4299 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4300 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4301 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4303 // Adaptation - begin
4304 #ifndef DISABLE_MG_ADAPT
4305 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4309 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4310 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4311 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4312 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4313 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4314 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4316 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4317 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4318 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4320 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4322 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4324 QList<int> aCtrlActions;
4325 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4326 << SMESHOp::OpNodeConnectivityNb // node controls
4327 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4328 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4329 << SMESHOp::OpDeflection2D
4330 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4331 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4332 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4333 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4334 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4335 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4336 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4337 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4338 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4339 aCtrlGroup->setExclusive( true );
4340 for( int i = 0; i < aCtrlActions.size(); i++ )
4341 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4343 // ----- create menu --------------
4344 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4345 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4346 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4347 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4348 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4349 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4350 #ifndef DISABLE_MG_ADAPT
4351 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4353 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4354 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4356 createMenu( separator(), fileId );
4358 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4359 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4360 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4361 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4362 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4363 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4364 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4365 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4366 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4367 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4368 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4369 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4370 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4372 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4373 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4374 createMenu( SMESHOp::OpImportMED, importId, -1 );
4375 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4377 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4379 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4380 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4381 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4382 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4383 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4384 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4386 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4388 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4389 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4390 createMenu( separator(), fileId, 10 );
4392 createMenu( SMESHOp::OpDelete, editId, -1 );
4394 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4396 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4397 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4398 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4399 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4400 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4401 createMenu( separator(), meshId, -1 );
4402 createMenu( SMESHOp::OpCompute, meshId, -1 );
4403 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4404 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4405 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4406 createMenu( separator(), meshId, -1 );
4407 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4408 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4409 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4410 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4411 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4412 createMenu( separator(), meshId, -1 );
4413 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4414 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4415 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4416 createMenu( separator(), meshId, -1 );
4417 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4418 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4419 createMenu( separator(), meshId, -1 );
4420 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4421 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4422 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4423 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4424 createMenu( separator(), meshId, -1 );
4426 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4427 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4428 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4429 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4430 createMenu( SMESHOp::OpLength, edgeId, -1 );
4431 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4432 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4433 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4434 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4435 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4436 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4437 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4438 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4439 createMenu( SMESHOp::OpArea, faceId, -1 );
4440 createMenu( SMESHOp::OpTaper, faceId, -1 );
4441 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4442 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4443 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4444 createMenu( SMESHOp::OpSkew, faceId, -1 );
4445 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4446 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4447 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4448 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4449 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4450 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4451 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4452 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4453 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4454 createMenu( separator(), ctrlId, -1 );
4455 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4456 createMenu( separator(), ctrlId, -1 );
4457 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4459 createMenu( SMESHOp::OpNode, addId, -1 );
4460 createMenu( SMESHOp::OpElem0D, addId, -1 );
4461 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4462 createMenu( SMESHOp::OpBall, addId, -1 );
4463 createMenu( SMESHOp::OpEdge, addId, -1 );
4464 createMenu( SMESHOp::OpTriangle, addId, -1 );
4465 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4466 createMenu( SMESHOp::OpPolygon, addId, -1 );
4467 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4468 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4469 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4470 createMenu( SMESHOp::OpPyramid, addId, -1 );
4471 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4472 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4473 createMenu( separator(), addId, -1 );
4474 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4475 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4476 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4477 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4478 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4479 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4480 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4481 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4482 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4483 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4484 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4485 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4487 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4488 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4489 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4490 createMenu( separator(), removeId, -1 );
4491 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4492 createMenu( separator(), removeId, -1 );
4493 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4495 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4496 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4498 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4499 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4500 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4501 createMenu( SMESHOp::OpRotation, transfId, -1 );
4502 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4503 createMenu( SMESHOp::OpScale, transfId, -1 );
4504 createMenu( SMESHOp::OpOffset, transfId, -1 );
4505 createMenu( SMESHOp::OpSewing, transfId, -1 );
4506 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4508 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4509 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4510 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4511 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4512 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4513 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4514 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4515 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4516 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4517 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4518 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4519 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4520 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4521 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4522 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4523 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4525 // Adaptation - begin
4526 #ifndef DISABLE_MG_ADAPT
4527 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4531 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4532 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4533 createMenu( SMESHOp::OpAngle, measureId, -1 );
4534 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4535 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4536 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4537 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4539 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4540 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4541 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4542 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4544 // ----- create toolbars --------------
4545 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4546 createTool( SMESHOp::OpCreateMesh, meshTb );
4547 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4548 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4549 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4550 createTool( SMESHOp::OpCopyMesh, meshTb );
4551 createTool( separator(), meshTb );
4552 createTool( SMESHOp::OpCompute, meshTb );
4553 createTool( SMESHOp::OpPreCompute, meshTb );
4554 createTool( SMESHOp::OpEvaluate, meshTb );
4555 createTool( SMESHOp::OpMeshOrder, meshTb );
4557 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4558 createTool( SMESHOp::OpMeshInformation, infoTb );
4559 //createTool( SMESHOp::OpStdInfo, meshTb );
4560 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4561 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4563 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4564 createTool( SMESHOp::OpCreateGroup, groupTb );
4565 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4566 createTool( SMESHOp::OpConstructGroup, groupTb );
4567 createTool( SMESHOp::OpEditGroup, groupTb );
4569 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4570 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4571 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4572 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4574 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4575 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4576 createTool( SMESHOp::OpLength, ctrl1dTb );
4577 createTool( SMESHOp::OpConnection, ctrl1dTb );
4578 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4580 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4581 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4582 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4583 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4584 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4585 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4586 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4587 createTool( SMESHOp::OpArea, ctrl2dTb );
4588 createTool( SMESHOp::OpTaper, ctrl2dTb );
4589 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4590 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4591 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4592 createTool( SMESHOp::OpSkew, ctrl2dTb );
4593 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4594 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4595 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4597 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4598 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4599 createTool( SMESHOp::OpVolume, ctrl3dTb );
4600 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4601 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4602 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4603 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4605 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4606 createTool( SMESHOp::OpNode, addElemTb );
4607 createTool( SMESHOp::OpElem0D, addElemTb );
4608 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4609 createTool( SMESHOp::OpBall, addElemTb );
4610 createTool( SMESHOp::OpEdge, addElemTb );
4611 createTool( SMESHOp::OpTriangle, addElemTb );
4612 createTool( SMESHOp::OpQuadrangle, addElemTb );
4613 createTool( SMESHOp::OpPolygon, addElemTb );
4614 createTool( SMESHOp::OpTetrahedron, addElemTb );
4615 createTool( SMESHOp::OpHexahedron, addElemTb );
4616 createTool( SMESHOp::OpPentahedron, addElemTb );
4617 createTool( SMESHOp::OpPyramid, addElemTb );
4618 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4619 createTool( SMESHOp::OpPolyhedron, addElemTb );
4621 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4622 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4623 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4624 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4625 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4626 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4627 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4628 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4629 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4630 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4631 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4632 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4633 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4635 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4636 createTool( SMESHOp::OpRemoveNodes, remTb );
4637 createTool( SMESHOp::OpRemoveElements, remTb );
4638 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4639 createTool( SMESHOp::OpClearMesh, remTb );
4641 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4642 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4643 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4645 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4646 createTool( SMESHOp::OpMergeNodes, transformTb );
4647 createTool( SMESHOp::OpMergeElements, transformTb );
4648 createTool( SMESHOp::OpTranslation, transformTb );
4649 createTool( SMESHOp::OpRotation, transformTb );
4650 createTool( SMESHOp::OpSymmetry, transformTb );
4651 createTool( SMESHOp::OpScale, transformTb );
4652 createTool( SMESHOp::OpOffset, transformTb );
4653 createTool( SMESHOp::OpSewing, transformTb );
4654 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4656 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4657 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4658 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4659 createTool( SMESHOp::OpExtrusion, modifyTb );
4660 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4661 createTool( SMESHOp::OpRevolution, modifyTb );
4662 createTool( SMESHOp::OpOrientation, modifyTb );
4663 createTool( SMESHOp::OpReorientFaces, modifyTb );
4664 createTool( SMESHOp::OpMoveNode, modifyTb );
4665 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4666 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4667 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4668 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4669 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4670 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4671 createTool( SMESHOp::OpSmoothing, modifyTb );
4672 createTool( SMESHOp::OpPatternMapping, modifyTb );
4674 // Adaptation - begin
4675 #ifndef DISABLE_MG_ADAPT
4676 int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
4677 createTool( SMESHOp::OpMGAdapt, adaptTb );
4681 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4682 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4684 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4685 createTool( SMESHOp::OpUpdate, dispModeTb );
4687 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4688 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4692 OB = "'ObjectBrowser'",
4693 View = "'" + SVTK_Viewer::Type() + "'",
4695 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4696 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4697 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4698 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4699 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4700 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4701 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4702 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4703 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4704 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4705 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4706 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4708 mesh_part = mesh + " " + subMesh + " " + group,
4709 mesh_group = mesh + " " + group,
4710 mesh_submesh = mesh + " " + subMesh,
4711 hyp_alg = hypo + " " + algo;
4713 // popup for object browser
4715 isInvisible("not( isVisible )"),
4716 isEmpty("numberOfNodes = 0"),
4717 isNotEmpty("numberOfNodes <> 0"),
4719 // has nodes, edges, etc in VISIBLE! actor
4720 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4721 hasElems("(count( elemTypes ) > 0)"),
4722 hasDifferentElems("(count( elemTypes ) > 1)"),
4723 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4724 hasBalls("({'BallElem'} in elemTypes)"),
4725 hasElems0d("({'Elem0d'} in elemTypes)"),
4726 hasEdges("({'Edge'} in elemTypes)"),
4727 hasFaces("({'Face'} in elemTypes)"),
4728 hasVolumes("({'Volume'} in elemTypes)"),
4729 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4731 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4732 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4733 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4734 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4735 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4736 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4738 popupMgr()->insert( separator(), -1, 0 );
4739 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4740 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4741 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4742 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4743 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4744 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4745 popupMgr()->insert( separator(), -1, 0 );
4746 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4747 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4748 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4749 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4750 popupMgr()->insert( separator(), -1, 0 );
4751 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4752 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4753 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4754 popupMgr()->insert( separator(), -1, 0 );
4755 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4756 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4757 popupMgr()->insert( separator(), -1, 0 );
4758 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4759 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4761 // Adaptation - begin
4762 #ifndef DISABLE_MG_ADAPT
4763 popupMgr()->insert( separator(), -1, 0 );
4764 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4765 popupMgr()->insert( separator(), -1, 0 );
4769 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4770 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4771 QString only_one_2D = only_one_non_empty + " && dim>1";
4773 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4774 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4775 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4776 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4777 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4779 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4781 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4782 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4783 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4785 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4786 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4787 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4788 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4790 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4792 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4793 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4794 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4795 popupMgr()->insert( separator(), -1, 0 );
4797 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4798 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4799 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4802 createPopupItem( SMESHOp::OpEditGroup, View, group );
4803 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4804 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4806 popupMgr()->insert( separator(), -1, 0 );
4807 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4808 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4809 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4810 popupMgr()->insert( separator(), -1, 0 );
4812 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4813 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4814 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4815 popupMgr()->insert( separator(), -1, 0 );
4817 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4818 QString aType = QString( "%1type in {%2}" ).arg( lc );
4819 aType = aType.arg( mesh_part );
4820 QString aMeshInVTK = aClient + "&&" + aType;
4822 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4823 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4824 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4826 //-------------------------------------------------
4828 //-------------------------------------------------
4829 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4831 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4832 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4833 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4835 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4836 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4837 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4839 popupMgr()->insert( separator(), -1, -1 );
4841 //-------------------------------------------------
4843 //-------------------------------------------------
4844 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4846 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4847 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4848 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4850 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4851 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4852 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4854 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4855 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4856 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4858 popupMgr()->insert( separator(), anId, -1 );
4860 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4861 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4862 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4864 //-------------------------------------------------
4866 //-------------------------------------------------
4867 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4869 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4871 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4872 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4873 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4875 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4876 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4877 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4879 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4880 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4881 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4883 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4884 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4885 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4887 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4888 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4889 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4891 popupMgr()->insert( separator(), anId, -1 );
4893 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4894 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4896 popupMgr()->insert( separator(), anId, -1 );
4898 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4899 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4902 //-------------------------------------------------
4903 // Representation of the 2D Quadratic elements
4904 //-------------------------------------------------
4905 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4906 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4907 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4908 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4910 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4911 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4912 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4914 //-------------------------------------------------
4915 // Orientation of faces
4916 //-------------------------------------------------
4917 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4918 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4919 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4921 //-------------------------------------------------
4923 //-------------------------------------------------
4924 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4925 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4927 //-------------------------------------------------
4929 //-------------------------------------------------
4930 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4931 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4933 //-------------------------------------------------
4935 //-------------------------------------------------
4937 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4938 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4939 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4940 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4942 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4944 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4945 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4947 popupMgr()->insert( separator(), anId, -1 );
4949 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4951 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4952 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4953 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4955 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4956 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4957 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4959 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4960 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4961 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4963 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4965 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4966 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4967 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4969 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4970 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4971 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4973 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4974 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4975 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4977 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4978 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4980 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4982 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4983 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4984 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4986 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4987 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4988 QtxPopupMgr::VisibleRule );
4989 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4991 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4992 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4993 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4995 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4996 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4997 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4999 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
5000 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5001 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
5003 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
5004 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5005 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
5007 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
5008 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5009 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5011 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5012 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5013 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5015 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5016 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5017 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5019 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5020 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5021 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5023 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5024 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5025 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5027 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5028 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5029 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5031 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5032 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5033 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5035 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5036 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5037 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5039 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5040 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5041 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5043 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5045 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5046 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5047 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5049 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5050 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5051 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5053 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5054 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5055 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5057 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5058 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5059 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5061 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5062 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5063 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5065 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5066 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5067 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5069 popupMgr()->insert( separator(), anId, -1 );
5071 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5072 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5073 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5074 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5075 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5077 popupMgr()->insert( separator(), anId, -1 );
5079 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5081 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5082 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5084 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5085 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5086 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5088 #ifndef DISABLE_PLOT2DVIEWER
5089 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5090 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5093 //-------------------------------------------------
5095 //-------------------------------------------------
5096 popupMgr()->insert( separator(), -1, -1 );
5097 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5098 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5099 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5100 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5102 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5103 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5105 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5106 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5108 popupMgr()->insert( separator(), -1, -1 );
5110 //-------------------------------------------------
5112 //-------------------------------------------------
5113 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5114 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5116 popupMgr()->insert( separator(), -1, -1 );
5118 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5119 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5120 popupMgr()->insert( separator(), -1, -1 );
5122 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5123 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5125 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5126 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5128 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5129 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5132 //================================================================================
5134 * \brief Return true if SMESH or GEOM objects are selected.
5135 * Is called form LightApp_Module::activateModule() which clear selection if
5136 * not isSelectionCompatible()
5138 //================================================================================
5140 bool SMESHGUI::isSelectionCompatible()
5142 bool isCompatible = true;
5143 SALOME_ListIO selected;
5144 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5145 Sel->selectedObjects( selected );
5147 SALOME_ListIteratorOfListIO It( selected );
5148 for ( ; isCompatible && It.More(); It.Next())
5150 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5151 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5152 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5154 return isCompatible;
5158 bool SMESHGUI::reusableOperation( const int id )
5160 // compute, evaluate and precompute are not reusable operations
5161 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5166 QString wrap(const QString& text, const QString& tag)
5167 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5170 bool SMESHGUI::activateModule( SUIT_Study* study )
5172 bool res = SalomeApp_Module::activateModule( study );
5174 setMenuShown( true );
5175 setToolShown( true );
5177 // Fill in Help Panel
5178 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5179 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5181 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5184 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5185 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5186 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5187 lab = lab + tr("INFO_REFINE") + ":";
5188 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5189 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5190 lab = lab + wrap(items.join(""), "ul");
5193 app->infoPanel()->addLabel(lab, gb);
5195 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5196 items << wrap("UNV", "li")
5197 << wrap("MED", "li")
5198 << wrap("STL", "li")
5199 << wrap("CGNS", "li")
5200 << wrap("SAUV", "li")
5201 << wrap("GMF", "li");
5202 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5205 app->infoPanel()->addLabel(lab, gb);
5207 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5208 lab = tr("INFO_DISPLAY") + "<br/>";
5209 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5210 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5211 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5212 << wrap("...", "li");
5213 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5215 lab = lab + tr("INFO_CLIPPING");
5217 app->infoPanel()->addLabel(lab, gb);
5220 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5221 PyGILState_STATE gstate = PyGILState_Ensure();
5222 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5223 if ( !pluginsmanager ) {
5227 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5232 PyGILState_Release(gstate);
5233 // end of SMESH plugins loading
5235 // Reset actions accelerator keys
5236 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5238 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5239 GetSMESHGen()->UpdateStudy();
5241 // get all view currently opened in the study and connect their signals to
5242 // the corresponding slots of the class.
5243 SUIT_Desktop* aDesk = study->application()->desktop();
5245 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5246 SUIT_ViewWindow* wnd;
5247 foreach ( wnd, wndList )
5251 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5252 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5258 Py_XDECREF(pluginsmanager);
5262 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5264 setMenuShown( false );
5265 setToolShown( false );
5267 EmitSignalCloseAllDialogs();
5269 // Unset actions accelerator keys
5270 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5272 return SalomeApp_Module::deactivateModule( study );
5275 void SMESHGUI::studyClosed( SUIT_Study* s )
5279 SMESH::RemoveVisuData();
5280 SalomeApp_Module::studyClosed( s );
5283 void SMESHGUI::OnGUIEvent()
5285 const QObject* obj = sender();
5286 if ( !obj || !obj->inherits( "QAction" ) )
5288 int id = actionId((QAction*)obj);
5293 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5295 if ( CORBA::is_nil( myComponentSMESH ) )
5297 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5298 return aGUI.myComponentSMESH;
5300 return myComponentSMESH;
5303 QString SMESHGUI::engineIOR() const
5305 CORBA::ORB_var anORB = getApp()->orb();
5306 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5307 return QString( anIOR.in() );
5310 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5312 SalomeApp_Module::contextMenuPopup( client, menu, title );
5314 selectionMgr()->selectedObjects( lst );
5315 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5316 Handle(SALOME_InteractiveObject) io = lst.First();
5317 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5318 _PTR(Study) study = appStudy->studyDS();
5319 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5321 QString aName = SMESH::fromUtf8( obj->GetName());
5322 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5323 aName.remove(( aName.length() - 1 ), 1 );
5329 LightApp_Selection* SMESHGUI::createSelection() const
5331 return new SMESHGUI_Selection();
5334 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5336 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5337 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5338 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5339 #ifndef DISABLE_PYCONSOLE
5340 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5344 void SMESHGUI::viewManagers( QStringList& list ) const
5346 list.append( SVTK_Viewer::Type() );
5349 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5351 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5352 SMESH::UpdateSelectionProp( this );
5354 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5355 for(int i = 0; i < aViews.count() ; i++){
5356 SUIT_ViewWindow *sf = aViews[i];
5359 EmitSignalActivatedViewManager();
5363 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5365 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5366 myClippingPlaneInfoMap.erase( theViewManager );
5369 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5371 theActor->AddObserver( SMESH::DeleteActorEvent,
5372 myEventCallbackCommand.GetPointer(),
5376 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5377 unsigned long theEvent,
5378 void* theClientData,
5379 void* /*theCallData*/ )
5381 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5382 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5383 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5384 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5385 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5386 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5387 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5388 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5389 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5390 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5391 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5392 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5393 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5394 if( anActor == *anIter3 ) {
5395 anActorList.erase( anIter3 );
5406 void SMESHGUI::createPreferences()
5408 // General tab ------------------------------------------------------------------------
5409 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5411 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5412 setPreferenceProperty( autoUpdate, "columns", 2 );
5413 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5414 setPreferenceProperty( lim, "min", 0 );
5415 setPreferenceProperty( lim, "max", 100000000 );
5416 setPreferenceProperty( lim, "step", 1000 );
5417 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5418 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5420 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5421 setPreferenceProperty( dispgroup, "columns", 2 );
5423 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5425 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5427 modes.append( tr("MEN_WIRE") );
5428 modes.append( tr("MEN_SHADE") );
5429 modes.append( tr("MEN_NODES") );
5430 modes.append( tr("MEN_SHRINK") );
5431 QList<QVariant> indices;
5432 indices.append( 0 );
5433 indices.append( 1 );
5434 indices.append( 2 );
5435 indices.append( 3 );
5436 setPreferenceProperty( dispmode, "strings", modes );
5437 setPreferenceProperty( dispmode, "indexes", indices );
5439 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5440 setPreferenceProperty( arcgroup, "columns", 2 );
5441 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5442 QStringList quadraticModes;
5443 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5444 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5446 indices.append( 0 );
5447 indices.append( 1 );
5448 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5449 setPreferenceProperty( quadraticmode, "indexes", indices );
5451 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5452 "SMESH", "max_angle" );
5453 setPreferenceProperty( maxAngle, "min", 1 );
5454 setPreferenceProperty( maxAngle, "max", 90 );
5456 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5457 setPreferenceProperty( qaGroup, "columns", 2 );
5458 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5459 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5460 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5461 setPreferenceProperty( prec, "min", 0 );
5462 setPreferenceProperty( prec, "max", 100 );
5463 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5464 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5465 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5466 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5467 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5470 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5471 setPreferenceProperty( cinc, "min", 0 );
5472 setPreferenceProperty( cinc, "max", 5 );
5475 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5476 setPreferenceProperty( exportgroup, "columns", 2 );
5477 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5478 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5479 addPreference( tr( "PREF_MED_SAVE_NUMS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "med_save_numbers" );
5480 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5481 setPreferenceProperty( zTol, "precision", 10 );
5482 setPreferenceProperty( zTol, "min", 0.0000000001 );
5483 setPreferenceProperty( zTol, "max", 1000000.0 );
5484 setPreferenceProperty( zTol, "step", 1. );
5485 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5487 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5488 setPreferenceProperty( computeGroup, "columns", 2 );
5489 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5491 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5492 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5493 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5495 indices.append( 0 );
5496 indices.append( 1 );
5497 indices.append( 2 );
5498 setPreferenceProperty( notifyMode, "strings", modes );
5499 setPreferenceProperty( notifyMode, "indexes", indices );
5501 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5502 setPreferenceProperty( infoGroup, "columns", 2 );
5503 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5505 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5506 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5508 indices.append( 0 );
5509 indices.append( 1 );
5510 setPreferenceProperty( elemInfo, "strings", modes );
5511 setPreferenceProperty( elemInfo, "indexes", indices );
5512 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5513 setPreferenceProperty( nodesLim, "min", 0 );
5514 setPreferenceProperty( nodesLim, "max", 10000000 );
5515 setPreferenceProperty( nodesLim, "step", 10000 );
5516 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5517 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5518 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5519 setPreferenceProperty( ctrlLim, "min", 0 );
5520 setPreferenceProperty( ctrlLim, "max", 10000000 );
5521 setPreferenceProperty( ctrlLim, "step", 1000 );
5522 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5523 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5524 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5525 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5526 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5528 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5529 setPreferenceProperty( segGroup, "columns", 2 );
5530 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5531 "SMESH", "segmentation" );
5532 setPreferenceProperty( segLen, "min", 1 );
5533 setPreferenceProperty( segLen, "max", 10000000 );
5534 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5535 "SMESH", "nb_segments_per_edge" );
5536 setPreferenceProperty( nbSeg, "min", 1 );
5537 setPreferenceProperty( nbSeg, "max", 10000000 );
5538 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5540 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5541 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5542 "SMESH", "forget_mesh_on_hyp_modif" );
5545 // Quantities with individual precision settings
5546 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5547 setPreferenceProperty( precGroup, "columns", 2 );
5549 const int nbQuantities = 6;
5550 int precs[nbQuantities], ii = 0;
5551 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5552 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5553 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5554 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5555 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5556 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5557 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5558 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5559 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5560 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5561 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5562 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5564 // Set property for precision value for spinboxes
5565 for ( ii = 0; ii < nbQuantities; ii++ ){
5566 setPreferenceProperty( precs[ii], "min", -14 );
5567 setPreferenceProperty( precs[ii], "max", 14 );
5568 setPreferenceProperty( precs[ii], "precision", 2 );
5571 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5572 setPreferenceProperty( previewGroup, "columns", 2 );
5573 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5574 setPreferenceProperty( chunkSize, "min", 1 );
5575 setPreferenceProperty( chunkSize, "max", 1000 );
5576 setPreferenceProperty( chunkSize, "step", 50 );
5578 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5579 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5581 // Mesh tab ------------------------------------------------------------------------
5582 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5583 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5584 setPreferenceProperty( nodeGroup, "columns", 3 );
5586 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5588 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5590 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5591 QList<QVariant> aMarkerTypeIndicesList;
5592 QList<QVariant> aMarkerTypeIconsList;
5593 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5594 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5595 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5596 aMarkerTypeIndicesList << i;
5597 aMarkerTypeIconsList << pixmap;
5599 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5600 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5602 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5604 QList<QVariant> aMarkerScaleIndicesList;
5605 QStringList aMarkerScaleValuesList;
5606 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5607 aMarkerScaleIndicesList << i;
5608 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5609 aMarkerScaleValuesList << QString::number( i );
5611 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5612 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5614 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5615 //setPreferenceProperty( elemGroup, "columns", 2 );
5617 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5618 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5619 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5620 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5621 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5622 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5623 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5624 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5625 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5628 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5629 setPreferenceProperty( grpGroup, "columns", 2 );
5631 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5632 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5634 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5635 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5636 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5637 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5638 int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5639 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5640 int ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5641 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5642 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5643 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5644 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5645 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5646 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5647 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5649 setPreferenceProperty( size0d, "min", 1 );
5650 setPreferenceProperty( size0d, "max", 10 );
5652 // setPreferenceProperty( ballSize, "min", 1 );
5653 // setPreferenceProperty( ballSize, "max", 10 );
5655 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5656 setPreferenceProperty( ballDiameter, "max", 1e9 );
5657 setPreferenceProperty( ballDiameter, "step", 0.1 );
5659 setPreferenceProperty( ballScale, "min", 1e-2 );
5660 setPreferenceProperty( ballScale, "max", 1e7 );
5661 setPreferenceProperty( ballScale, "step", 0.5 );
5663 setPreferenceProperty( elemW, "min", 1 );
5664 setPreferenceProperty( elemW, "max", 5 );
5666 setPreferenceProperty( outW, "min", 1 );
5667 setPreferenceProperty( outW, "max", 5 );
5669 setPreferenceProperty( shrink, "min", 0 );
5670 setPreferenceProperty( shrink, "max", 100 );
5672 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5673 setPreferenceProperty( numGroup, "columns", 2 );
5675 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5676 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5678 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5679 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5681 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5682 setPreferenceProperty( orientGroup, "columns", 1 );
5684 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5685 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5687 setPreferenceProperty( orientScale, "min", 0.05 );
5688 setPreferenceProperty( orientScale, "max", 0.5 );
5689 setPreferenceProperty( orientScale, "step", 0.05 );
5691 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5693 // Selection tab ------------------------------------------------------------------------
5694 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5696 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5697 setPreferenceProperty( selGroup, "columns", 2 );
5699 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5700 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5702 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5703 setPreferenceProperty( preGroup, "columns", 2 );
5705 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5707 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5708 setPreferenceProperty( precSelGroup, "columns", 2 );
5710 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5711 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5712 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5714 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5715 setPreferenceProperty( sinc, "min", 0 );
5716 setPreferenceProperty( sinc, "max", 5 );
5718 // Scalar Bar tab ------------------------------------------------------------------------
5719 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5720 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5721 setPreferenceProperty( fontGr, "columns", 2 );
5723 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5724 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5726 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5727 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5729 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5730 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5732 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5733 setPreferenceProperty( numcol, "min", 2 );
5734 setPreferenceProperty( numcol, "max", 256 );
5736 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5737 setPreferenceProperty( numlab, "min", 2 );
5738 setPreferenceProperty( numlab, "max", 65 );
5740 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5741 setPreferenceProperty( orientGr, "columns", 2 );
5742 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5743 QStringList orients;
5744 orients.append( tr( "SMESH_VERTICAL" ) );
5745 orients.append( tr( "SMESH_HORIZONTAL" ) );
5746 indices.clear(); indices.append( 0 ); indices.append( 1 );
5747 setPreferenceProperty( orient, "strings", orients );
5748 setPreferenceProperty( orient, "indexes", indices );
5750 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5751 setPreferenceProperty( posVSizeGr, "columns", 2 );
5752 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5753 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5754 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5755 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5756 setPreferenceProperty( xv, "step", 0.1 );
5757 setPreferenceProperty( xv, "min", 0.0 );
5758 setPreferenceProperty( xv, "max", 1.0 );
5759 setPreferenceProperty( yv, "step", 0.1 );
5760 setPreferenceProperty( yv, "min", 0.0 );
5761 setPreferenceProperty( yv, "max", 1.0 );
5762 setPreferenceProperty( wv, "step", 0.1 );
5763 setPreferenceProperty( wv, "min", 0.0 );
5764 setPreferenceProperty( wv, "max", 1.0 );
5765 setPreferenceProperty( hv, "min", 0.0 );
5766 setPreferenceProperty( hv, "max", 1.0 );
5767 setPreferenceProperty( hv, "step", 0.1 );
5769 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5770 setPreferenceProperty( posHSizeGr, "columns", 2 );
5771 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5772 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5773 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5774 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5775 setPreferenceProperty( xv, "min", 0.0 );
5776 setPreferenceProperty( xv, "max", 1.0 );
5777 setPreferenceProperty( xv, "step", 0.1 );
5778 setPreferenceProperty( xh, "min", 0.0 );
5779 setPreferenceProperty( xh, "max", 1.0 );
5780 setPreferenceProperty( xh, "step", 0.1 );
5781 setPreferenceProperty( yh, "min", 0.0 );
5782 setPreferenceProperty( yh, "max", 1.0 );
5783 setPreferenceProperty( yh, "step", 0.1 );
5784 setPreferenceProperty( wh, "min", 0.0 );
5785 setPreferenceProperty( wh, "max", 1.0 );
5786 setPreferenceProperty( wh, "step", 0.1 );
5787 setPreferenceProperty( hh, "min", 0.0 );
5788 setPreferenceProperty( hh, "max", 1.0 );
5789 setPreferenceProperty( hh, "step", 0.1 );
5791 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5792 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5793 setPreferenceProperty( distributionGr, "columns", 3 );
5795 types.append( tr( "SMESH_MONOCOLOR" ) );
5796 types.append( tr( "SMESH_MULTICOLOR" ) );
5797 indices.clear(); indices.append( 0 ); indices.append( 1 );
5798 setPreferenceProperty( coloringType, "strings", types );
5799 setPreferenceProperty( coloringType, "indexes", indices );
5800 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5802 // Adaptation - begin
5803 #ifndef DISABLE_MG_ADAPT
5804 // Adaptation tab ------------------------------------------------------------------------
5805 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5808 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5809 setPreferenceProperty( bloc, "columns", 1 );
5810 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5811 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5812 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5813 QStringList aListOfSizeMap;
5814 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5815 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5816 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5817 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5818 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5819 QStringList aListOfTimeStep;
5820 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5821 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5822 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5823 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5828 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5830 if ( sect=="SMESH" ) {
5831 double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5832 double aTol = 1.00000009999999;
5833 std::string aWarning;
5834 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5836 if ( name == "selection_object_color" ||
5837 name == "selection_element_color" ||
5838 name == "highlight_color" ||
5839 name == "selection_precision_node" ||
5840 name == "selection_precision_element" ||
5841 name == "selection_precision_object" ||
5842 name == "selection_increment")
5844 SMESH::UpdateSelectionProp( this );
5846 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5848 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5849 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5850 if ( sbX1+sbW > aTol ) {
5851 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5854 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5855 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5858 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5860 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5861 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5862 if ( sbY1 + sbH > aTol ) {
5863 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5864 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5865 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5868 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5870 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5871 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5872 if ( sbX1 + sbW > aTol ) {
5873 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5876 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5877 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5880 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5882 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5883 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5884 if ( sbY1 + sbH > aTol ) {
5885 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5888 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5889 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5892 else if ( name == "segmentation" )
5894 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5895 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5897 else if ( name == "nb_segments_per_edge" )
5899 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5900 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5902 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5904 QString val = aResourceMgr->stringValue( "SMESH", name );
5905 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5907 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5909 SMESH::UpdateFontProp( this );
5911 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5913 SMESH::UpdateFontProp( this );
5916 if ( aWarning.size() != 0 ) {
5917 aWarning += "The default values are applied instead.";
5918 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5919 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5920 QObject::tr(aWarning.c_str()));
5925 //================================================================================
5927 * \brief Update something in accordance with update flags
5928 * \param theFlags - update flags
5930 * Update viewer or/and object browser etc. in accordance with update flags ( see
5931 * LightApp_UpdateFlags enumeration ).
5933 //================================================================================
5934 void SMESHGUI::update( const int flags )
5936 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5937 SMESH::UpdateView();
5939 SalomeApp_Module::update( flags );
5942 //================================================================================
5944 * \brief Set default selection mode
5946 * SLOT called when operation committed. Sets default selection mode
5948 //================================================================================
5949 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5951 SVTK_ViewWindow* vtkWnd =
5952 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5954 vtkWnd->SetSelectionMode( ActorSelection );
5957 //================================================================================
5959 * \brief Set default selection mode
5961 * SLOT called when operation aborted. Sets default selection mode
5963 //================================================================================
5964 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5966 SVTK_ViewWindow* vtkWnd =
5967 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5969 vtkWnd->SetSelectionMode( ActorSelection );
5972 //================================================================================
5974 * \brief Creates operation with given identifier
5975 * \param id - identifier of operation to be started
5976 * \return Pointer on created operation or NULL if operation is not created
5978 * Virtual method redefined from the base class creates operation with given id.
5979 * It is called called automatically from startOperation method of base class.
5981 //================================================================================
5982 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5984 LightApp_Operation* op = 0;
5985 // to do : create operation here
5988 case SMESHOp::OpSplitBiQuadratic:
5989 op = new SMESHGUI_SplitBiQuadOp();
5991 case SMESHOp::OpConvertMeshToQuadratic:
5992 op = new SMESHGUI_ConvToQuadOp();
5994 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5995 op = new SMESHGUI_Make2DFrom3DOp();
5997 case SMESHOp::OpReorientFaces:
5998 op = new SMESHGUI_ReorientFacesOp();
6000 case SMESHOp::OpCreateMesh:
6001 op = new SMESHGUI_MeshOp( true, true );
6003 case SMESHOp::OpCreateSubMesh:
6004 op = new SMESHGUI_MeshOp( true, false );
6006 case SMESHOp::OpEditMeshOrSubMesh:
6007 case SMESHOp::OpEditMesh:
6008 case SMESHOp::OpEditSubMesh:
6009 op = new SMESHGUI_MeshOp( false );
6011 case SMESHOp::OpCompute:
6012 case SMESHOp::OpComputeSubMesh:
6013 op = new SMESHGUI_ComputeOp();
6015 case SMESHOp::OpShowErrors:
6016 op = new SMESHGUI_ShowErrorsOp();
6018 case SMESHOp::OpPreCompute:
6019 op = new SMESHGUI_PrecomputeOp();
6021 case SMESHOp::OpEvaluate:
6022 op = new SMESHGUI_EvaluateOp();
6024 case SMESHOp::OpMeshOrder:
6025 op = new SMESHGUI_MeshOrderOp();
6027 case SMESHOp::OpCreateGeometryGroup:
6028 op = new SMESHGUI_GroupOnShapeOp();
6030 case SMESHOp::OpFindElementByPoint:
6031 op = new SMESHGUI_FindElemByPointOp();
6033 case SMESHOp::OpMoveNode: // Make mesh pass through point
6034 op = new SMESHGUI_MakeNodeAtPointOp();
6036 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6037 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6044 op = SalomeApp_Module::createOperation( id );
6048 //================================================================================
6050 * \brief Stops current operations and starts a given one
6051 * \param id - The id of the operation to start
6053 //================================================================================
6055 void SMESHGUI::switchToOperation(int id)
6057 activeStudy()->abortAllOperations();
6058 startOperation( id );
6061 LightApp_Displayer* SMESHGUI::displayer()
6064 myDisplayer = new SMESHGUI_Displayer( getApp() );
6068 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6071 int aTolerance = 64;
6072 int anIterations = 0;
6078 if( anIterations % aPeriod == 0 )
6081 if( aTolerance < 1 )
6085 aHue = (int)( 360.0 * rand() / RAND_MAX );
6088 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6089 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6090 for( ; it != itEnd; ++it )
6092 SALOMEDS::Color anAutoColor = *it;
6093 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6096 aQColor.getHsv( &h, &s, &v );
6097 if( abs( h - aHue ) < aTolerance )
6109 aColor.setHsv( aHue, 255, 255 );
6111 SALOMEDS::Color aSColor;
6112 aSColor.R = aColor.redF();
6113 aSColor.G = aColor.greenF();
6114 aSColor.B = aColor.blueF();
6119 const char* gSeparator = "_"; // character used to separate parameter names
6120 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6121 const char* gPathSep = "|"; // character used to separate paths
6124 * \brief Store visual parameters
6126 * This method is called just before the study document is saved.
6127 * Store visual parameters in AttributeParameter attribute(s)
6129 void SMESHGUI::storeVisualParameters (int savePoint)
6132 Kernel_Utils::Localizer loc;
6134 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6135 if (!appStudy || !appStudy->studyDS())
6137 _PTR(Study) studyDS = appStudy->studyDS();
6139 // componentName is used for encoding of entries when storing them in IParameters
6140 std::string componentName = myComponentSMESH->ComponentDataType();
6141 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6142 //if (!aSComponent) return;
6145 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6146 componentName.c_str(),
6148 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6150 // store custom markers
6151 if( !myMarkerMap.empty() )
6153 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6154 for( ; anIter != myMarkerMap.end(); anIter++ )
6156 int anId = anIter->first;
6157 VTK::MarkerData aMarkerData = anIter->second;
6158 std::string aMarkerFileName = aMarkerData.first;
6159 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6160 if( aMarkerTexture.size() < 3 )
6161 continue; // should contain at least width, height and the first value
6163 QString aPropertyName( "texture" );
6164 aPropertyName += gSeparator;
6165 aPropertyName += QString::number( anId );
6167 QString aPropertyValue = aMarkerFileName.c_str();
6168 aPropertyValue += gPathSep;
6170 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6171 ushort aWidth = *aTextureIter++;
6172 ushort aHeight = *aTextureIter++;
6173 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6174 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6175 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6176 aPropertyValue += QString::number( *aTextureIter );
6178 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6182 // viewers counters are used for storing view_numbers in IParameters
6185 // main cycle to store parameters of displayed objects
6186 QList<SUIT_ViewManager*> lst;
6187 QList<SUIT_ViewManager*>::Iterator it;
6188 getApp()->viewManagers(lst);
6189 for (it = lst.begin(); it != lst.end(); it++)
6191 SUIT_ViewManager* vman = *it;
6192 QString vType = vman->getType();
6194 // saving VTK actors properties
6195 if (vType == SVTK_Viewer::Type())
6197 // store the clipping planes attached to the view manager
6198 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6199 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6200 if( anIter != myClippingPlaneInfoMap.end() )
6201 aClippingPlaneInfoList = anIter->second;
6203 if( !aClippingPlaneInfoList.empty() ) {
6204 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6205 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6207 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6208 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6210 QString aPropertyName( "ClippingPlane" );
6211 aPropertyName += gSeparator;
6212 aPropertyName += QString::number( vtkViewers );
6213 aPropertyName += gSeparator;
6214 aPropertyName += QString::number( anId );
6216 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6217 aPropertyValue += gDigitsSep;
6218 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6219 aPropertyValue += gDigitsSep;
6220 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6221 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6222 aPropertyValue += gDigitsSep;
6223 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6224 aPropertyValue += gDigitsSep;
6225 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6226 aPropertyValue += gDigitsSep;
6227 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6228 aPropertyValue += gDigitsSep;
6229 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6230 aPropertyValue += gDigitsSep;
6231 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6232 aPropertyValue += gDigitsSep;
6233 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6235 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6236 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6237 aPropertyValue += gDigitsSep;
6238 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6239 aPropertyValue += gDigitsSep;
6240 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6241 aPropertyValue += gDigitsSep;
6242 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6245 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6249 QVector<SUIT_ViewWindow*> views = vman->getViews();
6250 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6252 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6254 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6255 vtkActorCollection* allActors = aCopy.GetActors();
6256 allActors->InitTraversal();
6257 while (vtkActor* actor = allActors->GetNextActor())
6259 if (actor->GetVisibility()) // store only visible actors
6261 SMESH_Actor* aSmeshActor = 0;
6262 if (actor->IsA("SMESH_Actor"))
6263 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6264 if (aSmeshActor && aSmeshActor->hasIO())
6266 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6269 // entry is "encoded" = it does NOT contain component address,
6270 // since it is a subject to change on next component loading
6271 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6273 std::string param, vtkParam = vType.toLatin1().data();
6274 vtkParam += gSeparator;
6275 vtkParam += QString::number(vtkViewers).toLatin1().data();
6276 vtkParam += gSeparator;
6279 param = vtkParam + "Visibility";
6280 ip->setParameter(entry, param, "On");
6283 param = vtkParam + "Representation";
6284 ip->setParameter(entry, param, QString::number
6285 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6288 param = vtkParam + "IsShrunk";
6289 ip->setParameter(entry, param, QString::number
6290 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6292 // Displayed entities
6293 unsigned int aMode = aSmeshActor->GetEntityMode();
6294 bool isE = aMode & SMESH_Actor::eEdges;
6295 bool isF = aMode & SMESH_Actor::eFaces;
6296 bool isV = aMode & SMESH_Actor::eVolumes;
6297 bool is0d = aMode & SMESH_Actor::e0DElements;
6298 bool isB = aMode & SMESH_Actor::eBallElem;
6300 QString modeStr ("e");
6301 modeStr += gDigitsSep; modeStr += QString::number(isE);
6302 modeStr += gDigitsSep; modeStr += "f";
6303 modeStr += gDigitsSep; modeStr += QString::number(isF);
6304 modeStr += gDigitsSep; modeStr += "v";
6305 modeStr += gDigitsSep; modeStr += QString::number(isV);
6306 modeStr += gDigitsSep; modeStr += "0d";
6307 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6308 modeStr += gDigitsSep; modeStr += "b";
6309 modeStr += gDigitsSep; modeStr += QString::number(isB);
6311 param = vtkParam + "Entities";
6312 ip->setParameter(entry, param, modeStr.toLatin1().data());
6318 aSmeshActor->GetSufaceColor(r, g, b, delta);
6319 QStringList colorStr;
6320 colorStr << "surface";
6321 colorStr << QString::number(r);
6322 colorStr << QString::number(g);
6323 colorStr << QString::number(b);
6325 colorStr << "backsurface";
6326 colorStr << QString::number(delta);
6328 aSmeshActor->GetVolumeColor(r, g, b, delta);
6329 colorStr << "volume";
6330 colorStr << QString::number(r);
6331 colorStr << QString::number(g);
6332 colorStr << QString::number(b);
6333 colorStr << QString::number(delta);
6335 aSmeshActor->GetEdgeColor(r, g, b);
6337 colorStr << QString::number(r);
6338 colorStr << QString::number(g);
6339 colorStr << QString::number(b);
6341 aSmeshActor->GetNodeColor(r, g, b);
6343 colorStr << QString::number(r);
6344 colorStr << QString::number(g);
6345 colorStr << QString::number(b);
6347 aSmeshActor->GetOutlineColor(r, g, b);
6348 colorStr << "outline";
6349 colorStr << QString::number(r);
6350 colorStr << QString::number(g);
6351 colorStr << QString::number(b);
6353 aSmeshActor->Get0DColor(r, g, b);
6354 colorStr << "elem0d";
6355 colorStr << QString::number(r);
6356 colorStr << QString::number(g);
6357 colorStr << QString::number(b);
6359 aSmeshActor->GetBallColor(r, g, b);
6361 colorStr << QString::number(r);
6362 colorStr << QString::number(g);
6363 colorStr << QString::number(b);
6365 aSmeshActor->GetFacesOrientationColor(r, g, b);
6366 colorStr << "orientation";
6367 colorStr << QString::number(r);
6368 colorStr << QString::number(g);
6369 colorStr << QString::number(b);
6371 param = vtkParam + "Colors";
6372 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6375 QStringList sizeStr;
6377 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6378 sizeStr << "outline";
6379 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6380 sizeStr << "elem0d";
6381 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6383 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6384 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6385 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6386 sizeStr << "shrink";
6387 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6388 sizeStr << "orientation";
6389 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6390 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6392 param = vtkParam + "Sizes";
6393 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6398 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6399 if( aMarkerType == VTK::MT_USER ) {
6400 markerStr += "custom";
6401 markerStr += gDigitsSep;
6402 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6406 markerStr += gDigitsSep;
6407 markerStr += QString::number( (int)aMarkerType );
6408 markerStr += gDigitsSep;
6409 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6412 param = vtkParam + "PointMarker";
6413 ip->setParameter(entry, param, markerStr.toLatin1().data());
6416 param = vtkParam + "Opacity";
6417 ip->setParameter(entry, param,
6418 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6421 param = vtkParam + "ClippingPlane";
6423 if( !aClippingPlaneInfoList.empty() ) {
6424 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6425 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6427 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6428 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6429 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6430 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6431 if( aSmeshActor == *anIter2 ) {
6432 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6433 QString::number( anId ).toLatin1().constData() );
6440 ip->setParameter( entry, param, "Off" );
6441 } // if (io->hasEntry())
6442 } // SMESH_Actor && hasIO
6444 } // while.. actors traversal
6448 } // if (SVTK view model)
6449 } // for (viewManagers)
6452 // data structures for clipping planes processing
6456 bool isOpenGLClipping;
6457 vtkIdType RelativeOrientation;
6460 int AbsoluteOrientation;
6461 double X, Y, Z, Dx, Dy, Dz;
6463 typedef std::list<TPlaneData> TPlaneDataList;
6464 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6466 typedef std::list<vtkActor*> TActorList;
6469 TActorList ActorList;
6470 SUIT_ViewManager* ViewManager;
6472 typedef std::list<TPlaneInfo> TPlaneInfoList;
6473 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6476 * \brief Restore visual parameters
6478 * This method is called after the study document is opened.
6479 * Restore visual parameters from AttributeParameter attribute(s)
6481 void SMESHGUI::restoreVisualParameters (int savePoint)
6484 Kernel_Utils::Localizer loc;
6486 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6487 if (!appStudy || !appStudy->studyDS())
6489 _PTR(Study) studyDS = appStudy->studyDS();
6491 // componentName is used for encoding of entries when storing them in IParameters
6492 std::string componentName = myComponentSMESH->ComponentDataType();
6495 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6496 componentName.c_str(),
6498 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6500 // restore custom markers and map of clipping planes
6501 TPlaneDataMap aPlaneDataMap;
6503 std::vector<std::string> properties = ip->getProperties();
6504 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6506 std::string property = *propIt;
6507 QString aPropertyName( property.c_str() );
6508 QString aPropertyValue( ip->getProperty( property ).c_str() );
6510 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6511 if( aPropertyNameList.isEmpty() )
6514 QString aPropertyType = aPropertyNameList[0];
6515 if( aPropertyType == "texture" )
6517 if( aPropertyNameList.size() != 2 )
6521 int anId = aPropertyNameList[1].toInt( &ok );
6522 if( !ok || anId < 1 )
6525 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6526 if( aPropertyValueList.size() != 2 )
6529 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6530 QString aMarkerTextureString = aPropertyValueList[1];
6531 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6532 if( aMarkerTextureStringList.size() != 3 )
6536 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6541 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6545 VTK::MarkerTexture aMarkerTexture;
6546 aMarkerTexture.push_back( aWidth );
6547 aMarkerTexture.push_back( aHeight );
6549 QString aMarkerTextureData = aMarkerTextureStringList[2];
6550 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6552 QChar aChar = aMarkerTextureData.at( i );
6553 if( aChar.isDigit() )
6554 aMarkerTexture.push_back( aChar.digitValue() );
6557 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6559 else if( aPropertyType == "ClippingPlane" )
6561 if( aPropertyNameList.size() != 3 )
6565 int aViewId = aPropertyNameList[1].toInt( &ok );
6566 if( !ok || aViewId < 0 )
6570 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6571 if( !ok || aClippingPlaneId < 0 )
6574 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6575 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6578 TPlaneData aPlaneData;
6579 aPlaneData.AbsoluteOrientation = false;
6580 aPlaneData.RelativeOrientation = 0;
6581 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6582 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6583 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6585 aPlaneData.Id = aClippingPlaneId;
6588 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6593 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6597 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6600 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6605 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6610 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6615 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6620 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6625 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6630 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6634 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6636 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6641 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6646 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6651 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6656 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6657 aPlaneDataList.push_back( aPlaneData );
6661 TPlaneInfoMap aPlaneInfoMap;
6663 std::vector<std::string> entries = ip->getEntries();
6665 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6667 // entry is a normal entry - it should be "decoded" (setting base address of component)
6668 QString entry (ip->decodeEntry(*entIt).c_str());
6670 // Check that the entry corresponds to a real object in the Study
6671 // as the object may be deleted or modified after the visual state is saved.
6672 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6673 if (!so) continue; //Skip the not existent entry
6675 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6676 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6678 std::vector<std::string>::iterator namesIt = paramNames.begin();
6679 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6681 // actors are stored in a map after displaying of them for
6682 // quicker access in the future: map < viewID to actor >
6683 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6685 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6687 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6688 // '_' is used as separator and should not be used in viewer type or parameter names.
6689 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6690 if (lst.size() != 3)
6693 QString viewerTypStr = lst[0];
6694 QString viewIndexStr = lst[1];
6695 QString paramNameStr = lst[2];
6698 int viewIndex = viewIndexStr.toUInt(&ok);
6699 if (!ok) // bad conversion of view index to integer
6703 if (viewerTypStr == SVTK_Viewer::Type())
6705 SMESH_Actor* aSmeshActor = 0;
6706 if (vtkActors.IsBound(viewIndex))
6707 aSmeshActor = vtkActors.Find(viewIndex);
6709 QList<SUIT_ViewManager*> lst;
6710 getApp()->viewManagers(viewerTypStr, lst);
6712 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6713 SUIT_ViewManager* vman = NULL;
6714 if (viewIndex >= 0 && viewIndex < lst.count())
6715 vman = lst.at(viewIndex);
6717 if (paramNameStr == "Visibility")
6719 if (!aSmeshActor && displayer() && vman)
6721 SUIT_ViewModel* vmodel = vman->getViewModel();
6722 // SVTK view model can be casted to SALOME_View
6723 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6725 // store displayed actor in a temporary map for quicker
6726 // access later when restoring other parameters
6727 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6728 vtkRenderer* Renderer = vtkView->getRenderer();
6729 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6730 vtkActorCollection* theActors = aCopy.GetActors();
6731 theActors->InitTraversal();
6732 bool isFound = false;
6733 vtkActor *ac = theActors->GetNextActor();
6734 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6735 if (ac->IsA("SMESH_Actor")) {
6736 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6737 if (aGeomAc->hasIO()) {
6738 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6739 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6741 vtkActors.Bind(viewIndex, aGeomAc);
6747 } // if (paramNameStr == "Visibility")
6750 // the rest properties "work" with SMESH_Actor
6753 QString val ((*valuesIt).c_str());
6756 if (paramNameStr == "Representation") {
6757 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6760 else if (paramNameStr == "IsShrunk") {
6762 if (!aSmeshActor->IsShrunk())
6763 aSmeshActor->SetShrink();
6766 if (aSmeshActor->IsShrunk())
6767 aSmeshActor->UnShrink();
6770 // Displayed entities
6771 else if (paramNameStr == "Entities") {
6772 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6773 int aEntityMode = SMESH_Actor::eAllEntity;
6774 for ( int i = 0; i < mode.count(); i+=2 ) {
6775 if ( i < mode.count()-1 ) {
6776 QString type = mode[i];
6777 bool val = mode[i+1].toInt();
6778 if ( type == "e" && !val )
6779 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6780 else if ( type == "f" && !val )
6781 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6782 else if ( type == "v" && !val )
6783 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6784 else if ( type == "0d" && !val )
6785 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6786 else if ( type == "b" && !val )
6787 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6790 aSmeshActor->SetEntityMode( aEntityMode );
6793 else if (paramNameStr == "Colors") {
6794 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6801 QColor outlineColor;
6802 QColor orientationColor;
6808 // below lines are required to get default values for delta coefficients
6809 // of backface color for faces and color of reversed volumes
6810 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6811 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6812 for ( int i = 0; i < colors.count(); i++ ) {
6813 QString type = colors[i];
6814 if ( type == "surface" ) {
6815 // face color is set by 3 values r:g:b, where
6816 // - r,g,b - is rgb color components
6817 if ( i+1 >= colors.count() ) break; // format error
6818 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6819 if ( i+2 >= colors.count() ) break; // format error
6820 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6821 if ( i+3 >= colors.count() ) break; // format error
6822 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6823 faceColor.setRgbF( r, g, b );
6826 else if ( type == "backsurface" ) {
6827 // backface color can be defined in several ways
6828 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6829 // - in latest versions, it is set as delta coefficient
6830 bool rgbOk = false, deltaOk;
6831 if ( i+1 >= colors.count() ) break; // format error
6832 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6833 int delta = colors[i+1].toInt( &deltaOk );
6835 if ( i+1 < colors.count() ) // index is shifted to 1
6836 g = colors[i+1].toDouble( &rgbOk );
6837 if ( rgbOk ) i++; // shift index
6838 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6839 b = colors[i+1].toDouble( &rgbOk );
6841 // - as currently there's no way to set directly backsurface color as it was before,
6842 // we ignore old dump where r,g,b triple was set
6843 // - also we check that delta parameter is set properly
6844 if ( !rgbOk && deltaOk )
6847 else if ( type == "volume" ) {
6848 // volume color is set by 4 values r:g:b:delta, where
6849 // - r,g,b - is a normal volume rgb color components
6850 // - delta - is a reversed volume color delta coefficient
6851 if ( i+1 >= colors.count() ) break; // format error
6852 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6853 if ( i+2 >= colors.count() ) break; // format error
6854 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6855 if ( i+3 >= colors.count() ) break; // format error
6856 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6857 if ( i+4 >= colors.count() ) break; // format error
6858 int delta = colors[i+4].toInt( &bOk );
6859 if ( !bOk ) break; // format error
6860 volumeColor.setRgbF( r, g, b );
6864 else if ( type == "edge" ) {
6865 // edge color is set by 3 values r:g:b, where
6866 // - r,g,b - is rgb color components
6867 if ( i+1 >= colors.count() ) break; // format error
6868 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6869 if ( i+2 >= colors.count() ) break; // format error
6870 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6871 if ( i+3 >= colors.count() ) break; // format error
6872 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6873 edgeColor.setRgbF( r, g, b );
6876 else if ( type == "node" ) {
6877 // node color is set by 3 values r:g:b, where
6878 // - r,g,b - is rgb color components
6879 if ( i+1 >= colors.count() ) break; // format error
6880 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6881 if ( i+2 >= colors.count() ) break; // format error
6882 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6883 if ( i+3 >= colors.count() ) break; // format error
6884 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6885 nodeColor.setRgbF( r, g, b );
6888 else if ( type == "elem0d" ) {
6889 // 0d element color is set by 3 values r:g:b, where
6890 // - r,g,b - is rgb color components
6891 if ( i+1 >= colors.count() ) break; // format error
6892 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6893 if ( i+2 >= colors.count() ) break; // format error
6894 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6895 if ( i+3 >= colors.count() ) break; // format error
6896 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6897 elem0dColor.setRgbF( r, g, b );
6900 else if ( type == "ball" ) {
6901 // ball color is set by 3 values r:g:b, where
6902 // - r,g,b - is rgb color components
6903 if ( i+1 >= colors.count() ) break; // format error
6904 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6905 if ( i+2 >= colors.count() ) break; // format error
6906 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6907 if ( i+3 >= colors.count() ) break; // format error
6908 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6909 ballColor.setRgbF( r, g, b );
6912 else if ( type == "outline" ) {
6913 // outline color is set by 3 values r:g:b, where
6914 // - r,g,b - is rgb color components
6915 if ( i+1 >= colors.count() ) break; // format error
6916 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6917 if ( i+2 >= colors.count() ) break; // format error
6918 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6919 if ( i+3 >= colors.count() ) break; // format error
6920 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6921 outlineColor.setRgbF( r, g, b );
6924 else if ( type == "orientation" ) {
6925 // orientation color is set by 3 values r:g:b, where
6926 // - r,g,b - is rgb color components
6927 if ( i+1 >= colors.count() ) break; // format error
6928 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6929 if ( i+2 >= colors.count() ) break; // format error
6930 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6931 if ( i+3 >= colors.count() ) break; // format error
6932 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6933 orientationColor.setRgbF( r, g, b );
6938 if ( nodeColor.isValid() )
6939 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6941 if ( edgeColor.isValid() )
6942 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6944 if ( faceColor.isValid() )
6945 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6947 if ( volumeColor.isValid() )
6948 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6949 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6950 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6952 if ( elem0dColor.isValid() )
6953 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6955 if ( ballColor.isValid() )
6956 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6958 if ( outlineColor.isValid() )
6959 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6960 // orientation color
6961 if ( orientationColor.isValid() )
6962 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6965 else if (paramNameStr == "Sizes") {
6966 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6969 int outlineWidth = -1;
6970 int elem0dSize = -1;
6971 //int ballSize = -1;
6972 double ballDiameter = -1.0;
6973 double ballScale = -1.0;
6974 double shrinkSize = -1;
6975 double orientationSize = -1;
6976 bool orientation3d = false;
6977 for ( int i = 0; i < sizes.count(); i++ ) {
6978 QString type = sizes[i];
6979 if ( type == "line" ) {
6980 // line (wireframe) width is given as single integer value
6981 if ( i+1 >= sizes.count() ) break; // format error
6982 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6986 if ( type == "outline" ) {
6987 // outline width is given as single integer value
6988 if ( i+1 >= sizes.count() ) break; // format error
6989 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6993 else if ( type == "elem0d" ) {
6994 // 0d element size is given as single integer value
6995 if ( i+1 >= sizes.count() ) break; // format error
6996 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7000 else if ( type == "ball" ) {
7001 // balls are specified by two values: size:scale, where
7002 // - size - is a integer value specifying size
7003 // - scale - is a double value specifying scale factor
7004 if ( i+1 >= sizes.count() ) break; // format error
7005 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7006 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7007 if ( i+2 >= sizes.count() ) break; // format error
7008 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
7014 else if ( type == "shrink" ) {
7015 // shrink factor is given as single floating point value
7016 if ( i+1 >= sizes.count() ) break; // format error
7017 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7021 else if ( type == "orientation" ) {
7022 // orientation vectors are specified by two values size:3d, where
7023 // - size - is a floating point value specifying scale factor
7024 // - 3d - is a boolean
7025 if ( i+1 >= sizes.count() ) break; // format error
7026 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7027 if ( i+2 >= sizes.count() ) break; // format error
7028 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7029 orientationSize = v1;
7030 orientation3d = (bool)v2;
7034 // line (wireframe) width
7035 if ( lineWidth > 0 )
7036 aSmeshActor->SetLineWidth( lineWidth );
7038 if ( outlineWidth > 0 )
7039 aSmeshActor->SetOutlineWidth( outlineWidth );
7040 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7041 aSmeshActor->SetOutlineWidth( lineWidth );
7043 if ( elem0dSize > 0 )
7044 aSmeshActor->Set0DSize( elem0dSize );
7046 /*if ( ballSize > 0 )
7047 aSmeshActor->SetBallSize( ballSize );*/
7049 if ( ballDiameter > 0 )
7050 aSmeshActor->SetBallSize( ballDiameter );
7052 if ( ballScale > 0.0 )
7053 aSmeshActor->SetBallScale( ballScale );
7055 if ( shrinkSize > 0 )
7056 aSmeshActor->SetShrinkFactor( shrinkSize );
7057 // orientation vectors
7058 if ( orientationSize > 0 ) {
7059 aSmeshActor->SetFacesOrientationScale( orientationSize );
7060 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7064 else if (paramNameStr == "PointMarker") {
7065 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7066 if( data.count() >= 2 ) {
7068 int aParam1 = data[1].toInt( &ok );
7070 if( data[0] == "std" && data.count() == 3 ) {
7071 int aParam2 = data[2].toInt( &ok );
7072 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7074 else if( data[0] == "custom" ) {
7075 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7076 if( markerIt != myMarkerMap.end() ) {
7077 VTK::MarkerData aMarkerData = markerIt->second;
7078 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7085 else if (paramNameStr == "Opacity") {
7086 aSmeshActor->SetOpacity(val.toFloat());
7089 else if (paramNameStr.startsWith("ClippingPlane")) {
7090 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7091 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7092 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7093 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7094 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7095 // new format - val looks like "Off" or "0" (plane id)
7096 // (note: in new format "Off" value is used only for consistency,
7097 // so it is processed together with values in old format)
7098 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7099 if( anIsOldFormat ) {
7100 if (paramNameStr == "ClippingPlane1" || val == "Off")
7101 aSmeshActor->RemoveAllClippingPlanes();
7103 QList<SUIT_ViewManager*> lst;
7104 getApp()->viewManagers(viewerTypStr, lst);
7105 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7106 if (viewIndex >= 0 && viewIndex < lst.count()) {
7107 SUIT_ViewManager* vman = lst.at(viewIndex);
7108 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7110 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7112 SMESH::TActorList anActorList;
7113 anActorList.push_back( aSmeshActor );
7114 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7115 aPlane->myViewWindow = vtkView;
7116 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7117 aPlane->PlaneMode = aMode;
7118 bool isOpenGLClipping = ( bool )vals[1].toInt();
7119 aPlane->IsOpenGLClipping = isOpenGLClipping;
7120 if ( aMode == SMESH::Absolute ) {
7121 aPlane->myAbsoluteOrientation = vals[2].toInt();
7122 aPlane->X = vals[3].toFloat();
7123 aPlane->Y = vals[4].toFloat();
7124 aPlane->Z = vals[5].toFloat();
7125 aPlane->Dx = vals[6].toFloat();
7126 aPlane->Dy = vals[7].toFloat();
7127 aPlane->Dz = vals[8].toFloat();
7129 else if ( aMode == SMESH::Relative ) {
7130 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7131 aPlane->myDistance = vals[3].toFloat();
7132 aPlane->myAngle[0] = vals[4].toFloat();
7133 aPlane->myAngle[1] = vals[5].toFloat();
7137 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7138 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7139 aClippingPlaneInfo.Plane = aPlane;
7140 aClippingPlaneInfo.ActorList = anActorList;
7141 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7149 int aPlaneId = val.toInt( &ok );
7150 if( ok && aPlaneId >= 0 ) {
7151 bool anIsDefinedPlane = false;
7152 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7153 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7154 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7155 TPlaneInfo& aPlaneInfo = *anIter;
7156 if( aPlaneInfo.PlaneId == aPlaneId ) {
7157 aPlaneInfo.ActorList.push_back( aSmeshActor );
7158 anIsDefinedPlane = true;
7162 if( !anIsDefinedPlane ) {
7163 TPlaneInfo aPlaneInfo;
7164 aPlaneInfo.PlaneId = aPlaneId;
7165 aPlaneInfo.ActorList.push_back( aSmeshActor );
7166 aPlaneInfo.ViewManager = vman;
7168 // to make the list sorted by plane id
7169 anIter = aPlaneInfoList.begin();
7170 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7171 const TPlaneInfo& aPlaneInfoRef = *anIter;
7172 if( aPlaneInfoRef.PlaneId > aPlaneId )
7175 aPlaneInfoList.insert( anIter, aPlaneInfo );
7180 } // if (aSmeshActor)
7181 } // other parameters than Visibility
7183 } // for names/parameters iterator
7184 } // for entries iterator
7186 // take into account planes with empty list of actors referred to them
7187 QList<SUIT_ViewManager*> aVMList;
7188 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7190 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7191 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7192 int aViewId = aPlaneDataIter->first;
7193 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7194 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7196 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7198 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7199 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7200 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7201 const TPlaneData& aPlaneData = *anIter2;
7202 int aPlaneId = aPlaneData.Id;
7204 bool anIsFound = false;
7205 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7206 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7207 const TPlaneInfo& aPlaneInfo = *anIter3;
7208 if( aPlaneInfo.PlaneId == aPlaneId ) {
7215 TPlaneInfo aPlaneInfo; // ActorList field is empty
7216 aPlaneInfo.PlaneId = aPlaneId;
7217 aPlaneInfo.ViewManager = aViewManager;
7219 // to make the list sorted by plane id
7220 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7221 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7222 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7223 if( aPlaneInfoRef.PlaneId > aPlaneId )
7226 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7232 // add clipping planes to actors according to the restored parameters
7233 // and update the clipping plane map
7234 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7235 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7236 int aViewId = anIter1->first;
7237 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7239 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7240 if( anIter2 == aPlaneDataMap.end() )
7242 const TPlaneDataList& aPlaneDataList = anIter2->second;
7244 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7245 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7246 const TPlaneInfo& aPlaneInfo = *anIter3;
7247 int aPlaneId = aPlaneInfo.PlaneId;
7248 const TActorList& anActorList = aPlaneInfo.ActorList;
7249 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7253 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7257 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7259 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7260 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7261 const TPlaneData& aPlaneData = *anIter4;
7262 if( aPlaneData.Id == aPlaneId ) {
7263 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7264 aPlane->myViewWindow = aViewWindow;
7265 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7266 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7267 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7268 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7269 aPlane->X = aPlaneData.X;
7270 aPlane->Y = aPlaneData.Y;
7271 aPlane->Z = aPlaneData.Z;
7272 aPlane->Dx = aPlaneData.Dx;
7273 aPlane->Dy = aPlaneData.Dy;
7274 aPlane->Dz = aPlaneData.Dz;
7276 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7277 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7278 aPlane->myDistance = aPlaneData.Distance;
7279 aPlane->myAngle[0] = aPlaneData.Angle[0];
7280 aPlane->myAngle[1] = aPlaneData.Angle[1];
7283 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7284 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7285 aClippingPlaneInfo.Plane = aPlane;
7286 aClippingPlaneInfo.ActorList = anActorList;
7287 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7298 // update all VTK views
7299 QList<SUIT_ViewManager*> lst;
7300 getApp()->viewManagers(lst);
7301 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7302 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7303 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7304 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7305 // set OpenGL clipping planes
7306 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7307 vtkActorCollection* anAllActors = aCopy.GetActors();
7308 anAllActors->InitTraversal();
7309 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7310 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7311 anActor->SetOpenGLClippingPlane();
7313 vtkView->getRenderer()->ResetCameraClippingRange();
7320 \brief Adds preferences for dfont of VTK viewer
7322 \param pIf group identifier
7323 \param param parameter
7324 \return identifier of preferences
7326 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7328 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7330 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7333 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7334 fam.append( tr( "SMESH_FONT_COURIER" ) );
7335 fam.append( tr( "SMESH_FONT_TIMES" ) );
7337 setPreferenceProperty( tfont, "fonts", fam );
7339 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7340 if ( needSize ) f = f | QtxFontEdit::Size;
7341 setPreferenceProperty( tfont, "features", f );
7347 \brief Actions after hypothesis edition
7348 Updates object browser after hypothesis edition
7350 void SMESHGUI::onHypothesisEdit( int result )
7353 SMESHGUI::Modified();
7354 updateObjBrowser( true );
7358 \brief Actions after choosing menu of control modes
7359 Updates control mode actions according to current selection
7361 void SMESHGUI::onUpdateControlActions()
7363 SALOME_ListIO selected;
7364 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7365 aSel->selectedObjects( selected );
7367 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7368 if ( selected.Extent() ) {
7369 if ( selected.First()->hasEntry() ) {
7370 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7371 aControl = anActor->GetControlMode();
7372 SALOME_ListIteratorOfListIO it(selected);
7373 for ( it.Next(); it.More(); it.Next() ) {
7374 Handle(SALOME_InteractiveObject) anIO = it.Value();
7375 if ( anIO->hasEntry() ) {
7376 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7377 if ( aControl != anActor->GetControlMode() ) {
7378 aControl = SMESH_Actor::eNone;
7388 int anAction = ActionToControl( aControl, true );
7390 action( anAction )->setChecked( true );
7392 QMenu* send = (QMenu*)sender();
7393 QList<QAction*> actions = send->actions();
7394 for ( int i = 0; i < actions.size(); i++ )
7395 actions[i]->setChecked( false );
7401 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7402 \param pview view being closed
7404 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7405 #ifndef DISABLE_PLOT2DVIEWER
7406 //Crear all Plot2d Viewers if need.
7407 SMESH::ClearPlot2Viewers(pview);
7409 EmitSignalCloseView();
7412 void SMESHGUI::message( const QString& msg )
7415 QStringList data = msg.split("/");
7416 if ( data.count() > 0 ) {
7417 if ( data.first() == "mesh_loading" ) {
7419 QString entry = data.count() > 1 ? data[1] : QString();
7420 if ( entry.isEmpty() )
7423 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7425 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7428 name = SMESH::fromUtf8(obj->GetName());
7429 if ( name.isEmpty() )
7432 if ( data.last() == "stop" )
7433 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7435 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7436 QApplication::processEvents();
7442 \brief Connects or disconnects signals about activating and cloning view on the module slots
7443 \param pview view which is connected/disconnected
7445 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7449 SUIT_ViewManager* viewMgr = pview->getViewManager();
7451 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7452 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7454 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7455 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7460 \brief Return \c true if object can be renamed
7462 bool SMESHGUI::renameAllowed( const QString& entry) const {
7463 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7467 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7471 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7476 if(appStudy->isComponent(entry) || obj->isReference())
7479 // check type to prevent renaming of inappropriate objects
7480 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7481 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7482 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7483 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7484 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7485 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7492 Rename object by entry.
7493 \param entry entry of the object
7494 \param name new name of the object
7495 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7497 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7499 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7503 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7508 _PTR(Study) aStudy = appStudy->studyDS();
7513 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7515 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7520 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7521 _PTR(GenericAttribute) anAttr;
7522 _PTR(AttributeName) aName;
7524 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7526 // check type to prevent renaming of inappropriate objects
7527 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7528 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7529 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7530 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7531 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7532 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7533 if ( !name.isEmpty() ) {
7534 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7536 // update name of group object and its actor
7537 Handle(SALOME_InteractiveObject) IObject =
7538 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7540 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7541 if( !aGroupObject->_is_nil() ) {
7542 aGroupObject->SetName( qUtf8Printable(name) );
7543 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7544 anActor->setName( qUtf8Printable(name) );
7554 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7556 static QList<QColor> colors;
7558 if ( colors.isEmpty() ) {
7560 for (int s = 0; s < 2 ; s++)
7562 for (int v = 100; v >= 40; v = v - 20)
7564 for (int h = 0; h < 359 ; h = h + 60)
7566 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7571 static int currentColor = randomize( colors.size() );
7573 SALOMEDS::Color color;
7574 color.R = (double)colors[currentColor].red() / 255.0;
7575 color.G = (double)colors[currentColor].green() / 255.0;
7576 color.B = (double)colors[currentColor].blue() / 255.0;
7578 currentColor = (currentColor+1) % colors.count();