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_HomardAdaptDlg.h"
65 #include "SMESHGUI_Make2DFrom3DOp.h"
66 #include "SMESHGUI_MakeNodeAtPointDlg.h"
67 #include "SMESHGUI_Measurements.h"
68 #include "SMESHGUI_MergeDlg.h"
69 #include "SMESHGUI_MeshInfo.h"
70 #include "SMESHGUI_MeshOp.h"
71 #include "SMESHGUI_MeshOrderOp.h"
72 #include "SMESHGUI_MeshPatternDlg.h"
73 #include "SMESHGUI_MeshUtils.h"
74 #include "SMESHGUI_MultiEditDlg.h"
75 #include "SMESHGUI_NodesDlg.h"
76 #include "SMESHGUI_OffsetDlg.h"
77 #include "SMESHGUI_Operations.h"
78 #include "SMESHGUI_PatternUtils.h"
79 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
80 #include "SMESHGUI_PropertiesDlg.h"
81 #include "SMESHGUI_RemoveElementsDlg.h"
82 #include "SMESHGUI_RemoveNodesDlg.h"
83 #include "SMESHGUI_RenumberingDlg.h"
84 #include "SMESHGUI_ReorientFacesDlg.h"
85 #include "SMESHGUI_RevolutionDlg.h"
86 #include "SMESHGUI_RotationDlg.h"
87 #include "SMESHGUI_ScaleDlg.h"
88 #include "SMESHGUI_Selection.h"
89 #include "SMESHGUI_SewingDlg.h"
90 #include "SMESHGUI_SingleEditDlg.h"
91 #include "SMESHGUI_SmoothingDlg.h"
92 #include "SMESHGUI_SpinBox.h"
93 #include "SMESHGUI_SplitBiQuad.h"
94 #include "SMESHGUI_SymmetryDlg.h"
95 #include "SMESHGUI_TranslationDlg.h"
96 #include "SMESHGUI_TransparencyDlg.h"
97 #include "SMESHGUI_Utils.h"
98 #include "SMESHGUI_VTKUtils.h"
100 #include "SMESH_version.h"
102 #include "SMESH_Actor.h"
103 #include "SMESH_ActorUtils.h"
104 #include "SMESH_Client.hxx"
105 #include "SMESH_Comment.hxx"
106 #include "SMESH_ControlsDef.hxx"
107 #include "SMESH_ScalarBarActor.h"
108 #include "SMESH_TypeFilter.hxx"
109 #include "SMESH_Component_Generator.hxx"
111 // SALOME GUI includes
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
117 #include <QtxFontEdit.h>
118 #include <QtxPopupMgr.h>
119 #include <QtxInfoPanel.h>
120 #include <SALOME_ListIO.hxx>
121 #include <SUIT_Desktop.h>
122 #include <SUIT_FileDlg.h>
123 #include <SUIT_MessageBox.h>
124 #include <SUIT_OverrideCursor.h>
125 #include <SUIT_ResourceMgr.h>
126 #include <SUIT_Session.h>
127 #include <SVTK_Renderer.h>
128 #include <SVTK_ViewManager.h>
129 #include <SVTK_ViewModel.h>
130 #include <SVTK_ViewWindow.h>
131 #include <SalomeApp_Application.h>
132 #include <SalomeApp_CheckFileDlg.h>
133 #include <SalomeApp_DataObject.h>
134 #include <SalomeApp_Study.h>
135 #include <SalomeApp_Tools.h>
136 #include <VTKViewer_Algorithm.h>
138 #ifndef DISABLE_PLOT2DVIEWER
139 #include <SPlot2d_ViewModel.h>
140 #include <SPlot2d_Histogram.h>
144 #include <SALOMEconfig.h>
145 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
146 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
147 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
149 #include CORBA_CLIENT_HEADER(SMESH_Homard)
152 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
153 #include <QApplication>
155 #include <QDialogButtonBox>
159 #include <QTextStream>
163 #include <boost/shared_ptr.hpp>
166 #include <vtkCallbackCommand.h>
167 #include <vtkCamera.h>
168 #include <vtkLookupTable.h>
169 #include <vtkPlane.h>
170 #include <vtkRenderer.h>
172 // SALOME KERNEL includes
173 #include <Basics_Utils.hxx>
174 #include <SALOMEDSClient_ClientFactory.hxx>
175 #include <SALOMEDSClient_IParameters.hxx>
176 #include <SALOMEDSClient_SComponent.hxx>
177 #include <SALOMEDSClient_StudyBuilder.hxx>
178 #include <SALOMEDS_SObject.hxx>
179 #include <SALOMEDS_Study.hxx>
180 #include <SALOME_GenericObj_wrap.hxx>
181 #include <SALOME_LifeCycleCORBA.hxx>
182 #include <utilities.h>
185 #include <Standard_ErrorHandler.hxx>
186 #include <NCollection_DataMap.hxx>
187 #include <NCollection_DoubleMap.hxx>
189 // Below macro, when uncommented, switches on simplified (more performant) algorithm
190 // of auto-color picking up
191 #define SIMPLE_AUTOCOLOR
196 //=============================================================
197 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
200 void ExportMeshToFile(int theCommandID);
202 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
204 void SetDisplayEntity(int theCommandID);
206 int ActionToControl( int theID, bool theReversed = false );
208 void Control( int theCommandID );
211 //================================================================================
213 * \brief Reads meshes from file
215 //================================================================================
217 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
221 std::string myExtension;
223 if ( theCommandID == SMESHOp::OpImportMED ||
224 theCommandID == SMESHOp::OpPopupImportMED ) {
225 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
226 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
228 else if ( theCommandID == SMESHOp::OpImportUNV ||
229 theCommandID == SMESHOp::OpPopupImportUNV ) {
230 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
232 else if ( theCommandID == SMESHOp::OpImportDAT ||
233 theCommandID == SMESHOp::OpPopupImportDAT ) {
234 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
236 else if ( theCommandID == SMESHOp::OpImportSTL ||
237 theCommandID == SMESHOp::OpPopupImportSTL ) {
238 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
240 else if ( theCommandID == SMESHOp::OpImportCGNS ||
241 theCommandID == SMESHOp::OpPopupImportCGNS ) {
242 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
244 else if ( theCommandID == SMESHOp::OpImportGMF ||
245 theCommandID == SMESHOp::OpPopupImportGMF ) {
246 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
247 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
250 QString anInitialPath = "";
251 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
252 anInitialPath = QDir::currentPath();
254 QStringList filenames;
255 bool toCreateGroups = true;
257 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
258 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
259 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
260 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
261 // fd->setNameFilters( filter );
262 // fd->SetChecked( true );
264 // filenames << fd->selectedFile();
265 // toCreateGroups = fd->IsChecked();
271 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
274 QObject::tr( "SMESH_IMPORT_MESH" ) );
276 if ( filenames.count() > 0 )
278 SUIT_OverrideCursor wc;
279 _PTR(Study) aStudy = SMESH::getStudy();
282 QStringList anEntryList;
283 bool isEmpty = false;
284 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
286 QString filename = *it;
287 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
289 switch ( theCommandID ) {
290 case SMESHOp::OpImportDAT:
291 case SMESHOp::OpPopupImportDAT:
293 // DAT format (currently unsupported)
294 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
295 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
298 case SMESHOp::OpImportUNV:
299 case SMESHOp::OpPopupImportUNV:
302 aMeshes->length( 1 );
303 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
304 if ( aMeshes[0]->_is_nil() )
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
309 case SMESHOp::OpImportMED:
310 case SMESHOp::OpPopupImportMED:
313 SMESH::DriverMED_ReadStatus res;
314 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
315 if ( res != SMESH::DRS_OK ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
321 case SMESHOp::OpImportSTL:
322 case SMESHOp::OpPopupImportSTL:
325 aMeshes->length( 1 );
326 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
327 if ( aMeshes[0]->_is_nil() ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
333 case SMESHOp::OpImportCGNS:
334 case SMESHOp::OpPopupImportCGNS:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportGMF:
346 case SMESHOp::OpPopupImportGMF:
349 SMESH::ComputeError_var res;
350 aMeshes->length( 1 );
351 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
354 if ( res->code != SMESH::DRS_OK ) {
355 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
356 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
357 if ( strlen( res->comment.in() ) > 0 ) {
358 errors.back() += ": ";
359 errors.back() += res->comment.in();
366 catch ( const SALOME::SALOME_Exception& S_ex ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
371 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
373 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
375 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
376 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
377 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
378 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
379 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
381 anEntryList.append( aMeshSO->GetID().c_str() );
389 // update Object browser
390 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
392 // browse to the published meshes
393 if( LightApp_Application* anApp =
394 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
395 anApp->browseObjects( anEntryList );
397 // show Error message box if there were errors
398 if ( errors.count() > 0 ) {
399 SUIT_MessageBox::critical( SMESHGUI::desktop(),
400 QObject::tr( "SMESH_ERROR" ),
401 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
404 // show warning message box, if some imported mesh is empty
406 SUIT_MessageBox::warning( SMESHGUI::desktop(),
407 QObject::tr( "SMESH_WRN_WARNING" ),
408 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
413 //================================================================================
415 * \brief Export selected meshes or groups into a file
417 //================================================================================
419 void ExportMeshToFile( int theCommandID )
421 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
422 SALOME_ListIO selected;
424 aSel->selectedObjects( selected );
426 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
427 theCommandID == SMESHOp::OpPopupExportDAT );
428 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
429 theCommandID == SMESHOp::OpPopupExportMED );
430 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
431 theCommandID == SMESHOp::OpPopupExportUNV );
432 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
433 theCommandID == SMESHOp::OpPopupExportSTL );
434 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
435 theCommandID == SMESHOp::OpPopupExportCGNS );
436 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
437 theCommandID == SMESHOp::OpPopupExportGMF );
439 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
440 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
442 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
443 bool aCheckWarn = true;
445 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
447 // get mesh object from selection and check duplication of their names
448 bool hasDuplicatedMeshNames = false;
449 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
450 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
451 SALOME_ListIteratorOfListIO It( selected );
452 for( ; It.More(); It.Next() )
454 Handle(SALOME_InteractiveObject) anIObject = It.Value();
455 SMESH::SMESH_IDSource_var aMeshItem =
456 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
457 if ( aMeshItem->_is_nil() ) {
458 SUIT_MessageBox::warning( SMESHGUI::desktop(),
459 QObject::tr( "SMESH_WRN_WARNING" ),
460 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
463 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
464 if ( aCheckWarn && !aGroup->_is_nil() )
466 QMessageBox msgBox(SUIT_MessageBox::Warning,
467 QObject::tr("SMESH_WRN_WARNING"),
468 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
469 QMessageBox::StandardButton::NoButton,
470 SMESHGUI::desktop());
471 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
472 msgBox.addButton(QMessageBox::Ok);
473 msgBox.addButton(QMessageBox::Cancel);
474 msgBox.setDefaultButton(QMessageBox::Cancel);
475 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
476 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
477 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
478 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
479 if ( msgBox.exec() != QMessageBox::Ok )
482 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
483 resMgr->setValue( "SMESH", "show_warning", false);
486 QString aMeshName = anIObject->getName();
488 // check for name duplications
489 if ( !hasDuplicatedMeshNames )
490 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
491 if( aMeshName == (*aMeshIter).second ) {
492 hasDuplicatedMeshNames = true;
497 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
500 if( hasDuplicatedMeshNames && isMED ) {
501 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
502 QObject::tr("SMESH_WRN_WARNING"),
503 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
504 QObject::tr("SMESH_BUT_YES"),
505 QObject::tr("SMESH_BUT_NO"), 0, 1);
510 aMeshIter = aMeshList.begin();
511 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
512 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
513 QString aMeshName = (*aMeshIter).second;
515 if ( isMED || isCGNS ) // formats where group names must be unique
517 // check for equal group names within each mesh
518 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
519 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
520 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
521 int aRet = SUIT_MessageBox::warning
522 (SMESHGUI::desktop(),
523 QObject::tr("SMESH_WRN_WARNING"),
524 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
525 QObject::tr("SMESH_BUT_YES"),
526 QObject::tr("SMESH_BUT_NO"), 0, 1);
533 // Warn the user about presence of not supported elements
535 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
539 notSupportedElemTypes.push_back( SMESH::Entity_0D );
540 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
545 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
546 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
547 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
548 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
549 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
550 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
551 notSupportedElemTypes.push_back( SMESH::Entity_0D );
552 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
557 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
559 notSupportedElemTypes.push_back( SMESH::Entity_0D );
560 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
565 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
570 notSupportedElemTypes.push_back( SMESH::Entity_0D );
571 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
572 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
573 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
574 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
575 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
576 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
577 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
578 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
581 if ( ! notSupportedElemTypes.empty() )
583 SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
584 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
585 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
586 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
588 if ( !presentNotSupported.empty() )
591 const char* typeMsg[] = {
592 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
593 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
594 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
595 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
596 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
597 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
598 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
599 "SMESH_BIQUADRATIC_PENTAHEDRONS",
600 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
602 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
603 static_assert( sizeof(typeMsg) / sizeof(const char*) == SMESH::Entity_Last,
604 "Update names of EntityType's!!!" );
606 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
607 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
608 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
609 if ( iType != presentNotSupported.size() - 1 )
610 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
612 int aRet = SUIT_MessageBox::warning
613 (SMESHGUI::desktop(),
614 QObject::tr("SMESH_WRN_WARNING"),
615 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
616 QObject::tr("SMESH_BUT_YES"),
617 QObject::tr("SMESH_BUT_NO"), 0, 1);
622 // Get parameters of export operation
625 int aFormat =-1; // for MED version used for write
626 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
628 // Init the parameters with the default values
629 bool aIsASCII_STL = true;
630 bool toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
631 bool toOverwrite = true;
632 bool toFindOutDim = true;
633 bool saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
634 bool toRenumber = true;
635 double zTol = resMgr->doubleValue( "SMESH", "med_ztolerance", 0. );
637 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
638 QString anInitialPath = "";
639 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
640 anInitialPath = QDir::currentPath();
642 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
644 // Get a file name to write in and additional options
645 if ( isGMF ) // Export w/o options
647 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
648 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
649 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
651 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
652 anInitialPath + QString("/") + aMeshName,
653 aFilter, aTitle, false);
655 else if ( isCGNS || isUNV || isDAT ) // Export to [ CGNS | UNV | DAT ] - one option
657 const char* theOptionResource = isCGNS ? "cgns_group_elems_by_type" : "export_renumber";
658 bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
660 QStringList checkBoxes;
661 checkBoxes << QObject::tr( isCGNS ? "CGNS_EXPORT_ELEMS_BY_TYPE" : "SMESH_RENUMBER" );
663 SalomeApp_CheckFileDlg* fd =
664 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
665 fd->setWindowTitle( aTitle );
667 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
669 fd->setNameFilter( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
671 fd->setNameFilter( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
672 if ( !anInitialPath.isEmpty() )
673 fd->setDirectory( anInitialPath );
674 fd->selectFile( aMeshName );
675 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
676 fd->setValidator( fv );
677 fd->SetChecked( option, 0 );
680 aFilename = fd->selectedFile();
681 toOverwrite = fv->isOverwrite( aFilename );
682 option = fd->IsChecked( 0 );
683 SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
684 ( isCGNS ? toCreateGroups : toRenumber ) = option;
688 else if ( isSTL ) // Export to STL
690 QMap<QString, int> aFilterMap;
691 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
692 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
695 QMap<QString, int>::const_iterator it = aFilterMap.begin();
696 for ( ; it != aFilterMap.end(); ++it )
697 filters.push_back( it.key() );
699 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
700 fd->setWindowTitle( aTitle );
701 fd->setNameFilters( filters );
702 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
703 if ( !anInitialPath.isEmpty() )
704 fd->setDirectory( anInitialPath );
705 fd->selectFile(aMeshName);
709 aFilename = fd->selectedFile();
710 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
715 else if ( isMED ) // Export to MED
717 int defaultVersion = 0;
718 QMap<QString, int> aFilterMap;
719 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
720 //QString vmed (aMesh->GetVersionString(-1, 2));
721 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
722 if ( mvok->length() > 0)
723 defaultVersion = mvok[0]; // the current version to set the default filter on it
724 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
726 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
727 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
730 QMap<QString, int>::const_iterator it = aFilterMap.begin();
731 QString aDefaultFilter = it.key();
732 for ( ; it != aFilterMap.end(); ++it ) {
733 filters.push_back( it.key() );
734 if (it.value() == defaultVersion) // explicit default for MED = current MED version
735 aDefaultFilter = it.key();
737 QStringList checkBoxes;
738 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS")
739 << QObject::tr("SMESH_AUTO_DIM")
740 << QObject::tr("SMESH_MED_SAVE_NUMS");
742 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
743 QList< QWidget* > wdgList;
744 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
745 wdgList.append( fieldSelWdg );
747 QWidget* zTolWdg = new QWidget();
748 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
749 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
750 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
751 zTolLayout->addWidget( zTolCheck );
752 zTolLayout->addWidget( zTolSpin );
753 zTolLayout->setMargin( 0 );
754 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
755 zTolSpin->setValue( zTol );
756 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
757 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
758 zTolSpin ->setEnabled( zTolCheck->isChecked() );
759 wdgList.append( zTolWdg );
761 SalomeApp_CheckFileDlg* fd =
762 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
763 fd->setWindowTitle( aTitle );
764 fd->setNameFilters( filters );
765 fd->selectNameFilter( aDefaultFilter );
766 fd->SetChecked( toCreateGroups, 0 );
767 fd->SetChecked( toFindOutDim, 1 );
768 fd->SetChecked( saveNumbers, 2 );
769 if ( !anInitialPath.isEmpty() )
770 fd->setDirectory( anInitialPath );
771 fd->selectFile(aMeshName);
774 QListView *lview = fd->findChild<QListView*>("listView");
776 lview->setMinimumHeight(200);
778 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
780 tview->setMinimumHeight(200);
783 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
784 fd->setValidator( fv );
789 //MESSAGE("******* Loop on file dialog ***********");
792 aFilename = fd->selectedFile();
794 aFilename = QString::null;
797 aFormat = aFilterMap[fd->selectedNameFilter()];
798 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
799 toOverwrite = fv->isOverwrite(aFilename);
800 //MESSAGE("toOverwrite:" << toOverwrite);
802 if ( !aFilename.isEmpty() ) {
804 // append is only possible if the existing file format is compatible
805 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
806 MESSAGE("Append check, isVersionOk:" << isVersionOk);
807 if ( !isVersionOk ) {
808 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
809 QObject::tr("SMESH_WRN_WARNING"),
810 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
811 QObject::tr("SMESH_BUT_YES"),
812 QObject::tr("SMESH_BUT_NO"), 0, 1);
816 //MESSAGE("incompatible MED file version for add, overwrite accepted");
822 //MESSAGE("incompatible MED file version for add, overwrite refused");
825 QStringList aMeshNamesCollisionList;
826 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
827 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
828 QString anExistingMeshName( aMeshNames[ i ] );
829 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
830 QString anExportMeshName = (*aMeshIter).second;
831 if( anExportMeshName == anExistingMeshName ) {
832 aMeshNamesCollisionList.append( anExportMeshName );
837 if( !aMeshNamesCollisionList.isEmpty() ) {
839 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
840 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
841 QObject::tr("SMESH_WRN_WARNING"),
842 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
843 QObject::tr("SMESH_BUT_YES"),
844 QObject::tr("SMESH_BUT_NO"),
845 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
846 MESSAGE("answer collision name " << aRet);
857 toCreateGroups = fd->IsChecked(0);
858 toFindOutDim = fd->IsChecked(1);
859 saveNumbers = fd->IsChecked(2);
860 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
861 fieldSelWdg->GetSelectedFields();
862 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
864 if ( !fieldSelWdg->parent() )
866 if ( !zTolWdg->parent() )
877 if ( !aFilename.isEmpty() ) {
878 // Check whether the file already exists and delete it if yes
879 QFile aFile( aFilename );
880 if ( aFile.exists() && toOverwrite )
882 SUIT_OverrideCursor wc;
885 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
886 // bool Renumber = false;
887 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
889 // Renumber= resMgr->booleanValue("renumbering");
891 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
892 // aMeshEditor->RenumberNodes();
893 // aMeshEditor->RenumberElements();
894 // if ( SMESHGUI::automaticUpdate() )
895 // SMESH::UpdateView();
897 if ( isMED && isOkToWrite )
899 aMeshIter = aMeshList.begin();
900 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
902 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
903 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
904 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
905 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
907 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
908 toCreateGroups, aFormat,
909 toOverwrite && aMeshIndex == 0, toFindOutDim,
910 fields, geoAssFields.toLatin1().data(), zTol, saveNumbers );
915 if ( aMeshOrGroup->_is_equivalent( aMesh ))
916 aMesh->ExportDAT( aFilename.toUtf8().data(), toRenumber );
918 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
922 if ( aMeshOrGroup->_is_equivalent( aMesh ))
923 aMesh->ExportUNV( aFilename.toUtf8().data(), toRenumber );
925 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data(), toRenumber );
929 if ( aMeshOrGroup->_is_equivalent( aMesh ))
930 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
932 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
936 aMeshIter = aMeshList.begin();
937 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
939 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
940 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
941 aMeshItem->ExportCGNS( aMeshOrGroup,
942 aFilename.toUtf8().data(),
943 toOverwrite && aMeshIndex == 0,
949 toCreateGroups = true;
950 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
953 catch (const SALOME::SALOME_Exception& S_ex)
956 if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
957 strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
959 SUIT_MessageBox::critical(SMESHGUI::desktop(),
960 QObject::tr("SMESH_WRN_WARNING"),
961 QObject::tr(S_ex.details.text.in() ));
963 SUIT_MessageBox::warning(SMESHGUI::desktop(),
964 QObject::tr("SMESH_WRN_WARNING"),
965 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
971 inline void InverseEntityMode(unsigned int& theOutputMode,
972 unsigned int theMode)
974 bool anIsNotPresent = ~theOutputMode & theMode;
976 theOutputMode |= theMode;
978 theOutputMode &= ~theMode;
981 void SetDisplayEntity(int theCommandID)
983 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
984 SALOME_ListIO selected;
986 aSel->selectedObjects( selected );
988 if ( selected.Extent() >= 1 ) {
989 SUIT_OverrideCursor wc;
990 SALOME_ListIteratorOfListIO It( selected );
991 for( ; It.More(); It.Next()){
992 Handle(SALOME_InteractiveObject) IObject = It.Value();
993 if(IObject->hasEntry()){
994 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
995 unsigned int aMode = anActor->GetEntityMode();
996 switch(theCommandID){
997 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
998 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
999 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1000 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1001 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1002 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1005 anActor->SetEntityMode(aMode);
1014 SalomeApp_Application* app =
1015 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1019 LightApp_SelectionMgr* aSel = app->selectionMgr();
1020 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1021 if ( !aSel || !appStudy )
1024 SALOME_ListIO selected;
1025 aSel->selectedObjects( selected );
1026 if ( selected.IsEmpty() )
1029 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1031 _PTR(Study) aStudy = appStudy->studyDS();
1032 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1033 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1034 if ( aMainObject->_is_nil() )
1037 SUIT_OverrideCursor wc;
1039 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1041 QList<SALOMEDS::Color> aReservedColors;
1043 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1044 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1046 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1048 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1049 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1050 #else // old algorithm for auto-colors
1051 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1052 aReservedColors.append( aColor );
1053 #endif // SIMPLE_AUTOCOLOR
1054 aGroupObject->SetColor( aColor );
1056 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1057 if ( aGroupSObject ) {
1060 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1061 switch ( aGroupObject->GetType ()) {
1063 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1065 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1067 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1069 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1071 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1072 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1075 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1076 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1082 SMESH::RepaintCurrentView();
1085 void OverallMeshQuality()
1087 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1088 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1089 SALOME_ListIO selected;
1091 aSel->selectedObjects( selected );
1093 if ( selected.IsEmpty() ) return;
1094 SALOME_ListIteratorOfListIO It( selected );
1095 for ( ; It.More(); It.Next() ) {
1096 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1097 ctrlDlg->showInfo( It.Value() );
1102 QString functorToString( SMESH::Controls::FunctorPtr f )
1104 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1105 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1106 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1107 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1108 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1109 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1110 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1111 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1112 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1113 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1114 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1115 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1116 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1117 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1118 type = QObject::tr( "WARP_ELEMENTS" );
1119 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1120 type = QObject::tr( "TAPER_ELEMENTS" );
1121 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1122 type = QObject::tr( "SKEW_ELEMENTS" );
1123 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1124 type = QObject::tr( "AREA_ELEMENTS" );
1125 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1126 type = QObject::tr( "LENGTH_EDGES" );
1127 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1128 type = QObject::tr( "LENGTH2D_EDGES" );
1129 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1130 type = QObject::tr( "DEFLECTION2D_FACES" );
1131 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1132 type = QObject::tr( "MULTI_BORDERS" );
1133 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1134 type = QObject::tr( "MULTI2D_BORDERS" );
1135 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1136 type = QObject::tr( "FREE_NODES" );
1137 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1138 type = QObject::tr( "FREE_EDGES" );
1139 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1140 type = QObject::tr( "FREE_BORDERS" );
1141 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1142 type = QObject::tr( "FREE_FACES" );
1143 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1144 type = QObject::tr( "BARE_BORDER_VOLUME" );
1145 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1146 type = QObject::tr( "BARE_BORDER_FACE" );
1147 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1148 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1149 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1150 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1151 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1152 type = QObject::tr( "EQUAL_NODE" );
1153 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1154 type = QObject::tr( "EQUAL_EDGE" );
1155 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1156 type = QObject::tr( "EQUAL_FACE" );
1157 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1158 type = QObject::tr( "EQUAL_VOLUME" );
1159 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1160 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1164 void SaveDistribution()
1166 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1167 SALOME_ListIO selected;
1169 aSel->selectedObjects( selected );
1171 if ( selected.Extent() == 1 ) {
1172 Handle(SALOME_InteractiveObject) anIO = selected.First();
1173 if ( anIO->hasEntry() ) {
1174 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1176 anActor->GetScalarBarActor() &&
1177 anActor->GetControlMode() != SMESH_Actor::eNone )
1179 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1180 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1181 if ( aScalarBarActor && aFunctor ) {
1182 SMESH::Controls::NumericalFunctor* aNumFun =
1183 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1185 std::vector<smIdType> elements;
1186 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1187 if ( mesh->_is_nil() ) {
1188 SMESH::SMESH_IDSource_var idSource =
1189 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1190 if ( !idSource->_is_nil() )
1192 SMESH::smIdType_array_var ids = idSource->GetIDs();
1193 elements.resize( ids->length() );
1194 for ( unsigned i = 0; i < elements.size(); ++i )
1195 elements[i] = ids[i];
1198 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1199 vtkLookupTable* lookupTable =
1200 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1201 double * minmax = lookupTable->GetRange();
1202 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1203 std::vector<int> nbEvents;
1204 std::vector<double> funValues;
1205 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1206 elements, minmax, isLogarithmic );
1207 QString anInitialPath = "";
1208 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1209 anInitialPath = QDir::currentPath();
1210 QString aMeshName = anIO->getName();
1212 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1213 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1214 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1215 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1216 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1219 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1221 if ( !aFilename.isEmpty() ) {
1222 QFile f( aFilename );
1223 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1224 QTextStream out( &f );
1225 out << "# Mesh: " << aMeshName << endl;
1226 out << "# Control: " << functorToString( aFunctor ) << endl;
1228 out.setFieldWidth( 10 );
1229 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1230 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1241 void ShowElement( int theCommandID )
1243 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1244 SALOME_ListIO selected;
1246 aSel->selectedObjects( selected );
1248 if ( selected.Extent() == 1 ) {
1249 Handle(SALOME_InteractiveObject) anIO = selected.First();
1250 if ( anIO->hasEntry() ) {
1251 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1253 anActor->GetScalarBarActor() &&
1254 anActor->GetControlMode() != SMESH_Actor::eNone )
1256 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1257 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1258 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1260 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1261 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1268 #ifndef DISABLE_PLOT2DVIEWER
1269 void PlotDistribution()
1271 SalomeApp_Application* app =
1272 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1276 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1277 SALOME_ListIO selected;
1279 aSel->selectedObjects( selected );
1281 if ( selected.Extent() == 1 ) {
1282 Handle(SALOME_InteractiveObject) anIO = selected.First();
1283 if ( anIO->hasEntry() ) {
1284 //Find Actor by entry before getting Plot2d viewer,
1285 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1286 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1288 SUIT_ViewManager* aViewManager =
1289 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1293 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1297 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1301 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1303 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1304 QString functorName = functorToString( anActor->GetFunctor());
1305 QString aHistogramName("%1 : %2");
1306 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1307 aHistogram->setName(aHistogramName);
1308 aHistogram->setHorTitle(functorName);
1309 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1310 aPlot->displayObject(aHistogram, true);
1315 #endif //DISABLE_PLOT2DVIEWER
1317 void DisableAutoColor()
1319 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1320 SALOME_ListIO selected;
1322 aSel->selectedObjects( selected );
1324 if ( selected.Extent() ) {
1325 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1326 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1327 if ( !aMesh->_is_nil() ) {
1328 aMesh->SetAutoColor( false );
1335 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1336 SALOME_ListIO selected;
1338 aSel->selectedObjects( selected );
1339 if ( selected.Extent() )
1341 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1342 _PTR(Study) aStudy = SMESH::getStudy();
1343 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1345 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1346 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1353 // Break link with Shaper model
1354 void breakShaperLink()
1356 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1357 SALOME_ListIO selected;
1359 aSel->selectedObjects(selected);
1360 if (selected.Extent()) {
1361 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1362 _PTR(Study) aStudy = SMESH::getStudy();
1363 std::string aEntry = anIObject->getEntry();
1364 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1366 std::string aName = aSObj->GetName();
1367 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1368 QObject::tr("SMESH_WRN_WARNING"),
1369 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1370 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1371 if (aRes == SUIT_MessageBox::Yes) {
1372 SUIT_DataOwnerPtrList aList;
1373 aSel->selected(aList, "ObjectBrowser", true);
1374 SUIT_DataOwner* aOwn = aList.first();
1375 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1376 QString aREntry = sowner->entry();
1378 static GEOM::GEOM_Gen_var geomGen;
1379 if (CORBA::is_nil(geomGen)) {
1380 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1381 (SUIT_Session::session()->activeApplication());
1383 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1384 Engines::EngineComponent_var comp =
1385 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1386 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1389 if (!CORBA::is_nil(geomGen))
1391 geomGen->BreakLink(aREntry.toStdString().c_str());
1392 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1394 // remove actors whose objects are removed by BreakLink()
1395 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1396 SUIT_ViewWindow* wnd;
1397 foreach(wnd, wndList)
1398 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1406 //================================================================================
1408 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1409 * which means that the mesh can't be modified. It should be either re-computed
1410 * or breakShaperLink()'ed. Warn the user about it.
1412 //================================================================================
1414 bool warnOnGeomModif()
1416 SALOME_ListIO selected;
1417 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1418 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1420 SALOME_ListIteratorOfListIO It( selected );
1421 for ( ; It.More(); It.Next() )
1423 Handle(SALOME_InteractiveObject) io = It.Value();
1424 if ( !io->hasEntry() ) continue;
1425 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1426 SMESH::SMESH_Mesh_var mesh;
1427 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1429 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1430 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1431 if ( isrc->_is_nil() )
1432 so = so->GetFather();
1434 mesh = isrc->GetMesh();
1436 if ( mesh->_is_nil() ) continue;
1437 so = SMESH::FindSObject( mesh );
1438 if ( !so ) continue;
1439 _PTR(GenericAttribute) attr;
1440 so->FindAttribute( attr, "AttributePixMap" );
1441 _PTR(AttributePixMap) pixmap = attr;
1442 if ( !pixmap ) continue;
1444 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1446 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1447 QObject::tr("SMESH_WRN_WARNING"),
1448 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1455 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1457 SALOME_ListIO selected;
1458 SalomeApp_Application* app =
1459 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1463 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1464 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1465 if ( !aSel || !appStudy )
1468 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1469 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1470 aModule->EmitSignalDeactivateDialog();
1471 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1472 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1477 aSel->selectedObjects( selected );
1479 if ( selected.Extent() >= 1 )
1481 switch ( theCommandID ) {
1482 case SMESHOp::OpTransparency:
1484 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1485 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1488 case SMESHOp::OpProperties:
1491 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1492 QColor orientationColor, outlineColor, volumeColor;
1493 int deltaF = 0, deltaV = 0;
1496 double ballScale = 1.0;
1498 int outlineWidth = 1;
1499 double shrinkCoef = 0.0;
1500 double orientationScale = 0.0;
1501 bool orientation3d = false;
1502 VTK::MarkerType markerType = VTK::MT_NONE;
1503 VTK::MarkerScale markerScale = VTK::MS_NONE;
1505 bool hasNodes = false;
1506 int presentEntities = 0;
1507 bool firstTime = true;
1509 SALOME_ListIteratorOfListIO It( selected );
1510 for ( ; It.More(); It.Next() ) {
1511 Handle(SALOME_InteractiveObject) IObject = It.Value();
1512 if ( !IObject->hasEntry() ) continue;
1513 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1514 if ( !anActor || !anActor->GetObject() ) continue;
1517 // nodes: color, marker
1518 anActor->GetNodeColor( color[0], color[1], color[2] );
1519 nodeColor.setRgbF( color[0], color[1], color[2] );
1520 markerType = anActor->GetMarkerType();
1521 markerScale = anActor->GetMarkerScale();
1522 markerId = anActor->GetMarkerTexture();
1523 // edges: color, width
1524 anActor->GetEdgeColor( color[0], color[1], color[2] );
1525 edgeColor.setRgbF( color[0], color[1], color[2] );
1526 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1527 // faces: front color, back color (delta)
1528 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1529 faceColor.setRgbF( color[0], color[1], color[2] );
1530 // faces: front color, back color (delta)
1531 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1532 volumeColor.setRgbF( color[0], color[1], color[2] );
1533 // 0d elements: color, size
1534 anActor->Get0DColor( color[0], color[1], color[2] );
1535 elem0dColor.setRgbF( color[0], color[1], color[2] );
1536 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1537 // balls: color, size
1538 anActor->GetBallColor( color[0], color[1], color[2] );
1539 ballColor.setRgbF( color[0], color[1], color[2] );
1540 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1541 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1543 anActor->GetOutlineColor( color[0], color[1], color[2] );
1544 outlineColor.setRgbF( color[0], color[1], color[2] );
1545 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1546 // orientation vectors: color, scale, 3d flag
1547 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1548 orientationColor.setRgbF( color[0], color[1], color[2] );
1549 orientationScale = anActor->GetFacesOrientationScale();
1550 orientation3d = anActor->GetFacesOrientation3DVectors();
1552 shrinkCoef = anActor->GetShrinkFactor();
1555 firstTime = false; // we only take properties from first object (for performance reasons)
1558 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1559 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1560 presentEntities = presentEntities | SMESH_Actor::eEdges;
1561 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1562 presentEntities = presentEntities | SMESH_Actor::eFaces;
1563 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1564 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1565 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1566 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1567 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1568 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1570 // as we know that all types of elements are present, we can exit the loop
1571 if ( presentEntities == SMESH_Actor::eAllEntity )
1575 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1576 // nodes: color, marker
1577 dlg.setNodeColor( nodeColor );
1578 if( markerType != VTK::MT_USER )
1579 dlg.setNodeMarker( markerType, markerScale );
1581 dlg.setNodeCustomMarker( markerId );
1582 // edges: color, line width
1583 dlg.setEdgeColor( edgeColor );
1584 dlg.setEdgeWidth( edgeWidth );
1585 // faces: front color, back color
1586 dlg.setFaceColor( faceColor, deltaF );
1587 // volumes: normal color, reversed color
1588 dlg.setVolumeColor( volumeColor, deltaV );
1589 // outlines: color, line width
1590 dlg.setOutlineColor( outlineColor );
1591 dlg.setOutlineWidth( outlineWidth );
1592 // 0d elements: color, size
1593 dlg.setElem0dColor( elem0dColor );
1594 dlg.setElem0dSize( elem0dSize );
1595 // balls: color, size
1596 dlg.setBallColor( ballColor );
1597 //dlg.setBallSize( ballSize );
1598 dlg.setBallScale( ballScale );
1599 // orientation: color, scale, 3d flag
1600 dlg.setOrientationColor( orientationColor );
1601 dlg.setOrientationSize( int( orientationScale * 100. ) );
1602 dlg.setOrientation3d( orientation3d );
1603 // shrink: scale factor
1604 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1605 // hide unused controls
1606 dlg.showControls( presentEntities, hasNodes );
1609 nodeColor = dlg.nodeColor();
1610 markerType = dlg.nodeMarkerType();
1611 markerScale = dlg.nodeMarkerScale();
1612 markerId = dlg.nodeMarkerId();
1613 edgeColor = dlg.edgeColor();
1614 edgeWidth = dlg.edgeWidth();
1615 faceColor = dlg.faceColor();
1616 deltaF = dlg.faceColorDelta();
1617 volumeColor = dlg.volumeColor();
1618 deltaV = dlg.volumeColorDelta();
1619 outlineColor = dlg.outlineColor();
1620 outlineWidth = dlg.outlineWidth();
1621 elem0dColor = dlg.elem0dColor();
1622 elem0dSize = dlg.elem0dSize();
1623 ballColor = dlg.ballColor();
1624 // ballSize = dlg.ballSize();
1625 ballScale = dlg.ballScale();
1626 orientationColor = dlg.orientationColor();
1627 orientationScale = dlg.orientationSize() / 100.;
1628 orientation3d = dlg.orientation3d();
1629 shrinkCoef = dlg.shrinkCoef() / 100.;
1631 // store point markers that might be changed by the user
1632 theMarkerMap = dlg.customMarkers();
1634 // set properties from dialog box to the presentations
1635 SALOME_ListIteratorOfListIO It( selected );
1636 for ( ; It.More(); It.Next() ) {
1637 Handle(SALOME_InteractiveObject) IObject = It.Value();
1638 if ( !IObject->hasEntry() ) continue;
1639 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1640 if ( !anActor ) continue;
1642 // nodes: color, marker
1643 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1644 if ( markerType != VTK::MT_USER ) {
1645 anActor->SetMarkerStd( markerType, markerScale );
1648 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1649 if ( iter != theMarkerMap.end() )
1650 anActor->SetMarkerTexture( markerId, iter->second.second );
1652 // volumes: normal color, reversed color (delta)
1653 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1654 // faces: front color, back color (delta)
1655 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1656 // edges: color, width
1657 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1658 anActor->SetLineWidth( edgeWidth );
1660 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1661 anActor->SetOutlineWidth( outlineWidth );
1662 // 0D elements: color, size
1663 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1664 anActor->Set0DSize( elem0dSize );
1665 // balls: color, size
1666 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1667 // anActor->SetBallSize( ballSize );
1668 anActor->SetBallScale( ballScale );
1669 // orientation: color, scale, 3d flag
1670 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1671 anActor->SetFacesOrientationScale( orientationScale );
1672 anActor->SetFacesOrientation3DVectors( orientation3d );
1674 anActor->SetShrinkFactor( shrinkCoef );
1676 // for groups, set also proper color
1677 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1678 if ( !aGroupObject->_is_nil() ) {
1679 SMESH::ElementType anElementType = aGroupObject->GetType();
1681 switch( anElementType ) {
1683 aColor = nodeColor; break;
1685 aColor = edgeColor; break;
1687 aColor = faceColor; break;
1689 aColor = volumeColor; break;
1691 aColor = elem0dColor; break;
1693 aColor = ballColor; break;
1697 if ( aColor.isValid() ) {
1698 SALOMEDS::Color aGroupColor;
1699 aGroupColor.R = aColor.redF();
1700 aGroupColor.G = aColor.greenF();
1701 aGroupColor.B = aColor.blueF();
1702 aGroupObject->SetColor( aGroupColor );
1704 } // if ( !aGroupObject->_is_nil() )
1705 } // for ( ; It.More(); It.Next() )
1706 SMESH::RepaintCurrentView();
1707 } // if ( dlg.exec() )
1709 } // case SMESHOp::OpProperties:
1710 } // switch(theCommandID)
1711 SUIT_OverrideCursor wc;
1712 SALOME_ListIteratorOfListIO It( selected );
1713 for( ; It.More(); It.Next()){
1714 Handle(SALOME_InteractiveObject) IObject = It.Value();
1715 if(IObject->hasEntry()){
1716 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1717 switch(theCommandID){
1718 case SMESHOp::OpDMWireframe:
1719 anActor->SetRepresentation(SMESH_Actor::eEdge);
1721 case SMESHOp::OpDMShading:
1722 anActor->SetRepresentation(SMESH_Actor::eSurface);
1724 case SMESHOp::OpDMShrink:
1725 if(anActor->IsShrunk())
1726 anActor->UnShrink();
1728 anActor->SetShrink();
1730 case SMESHOp::OpDMNodes:
1731 anActor->SetRepresentation(SMESH_Actor::ePoint);
1733 case SMESHOp::OpRepresentationLines:
1734 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1735 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1737 case SMESHOp::OpRepresentationArcs:
1738 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1739 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1745 SMESH::RepaintCurrentView();
1749 int ActionToControl( int theID, bool theReversed )
1751 NCollection_DoubleMap<int,int> ActionControl;
1752 ActionControl.Bind( 0, SMESH_Actor::eNone );
1753 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1754 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1755 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1756 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1757 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1758 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1759 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1760 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1761 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1762 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1763 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1764 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1765 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1766 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1767 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1768 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1769 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1770 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1771 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1772 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1773 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1774 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1775 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1776 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1777 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1778 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1779 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1780 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1783 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1784 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1787 void Control( int theCommandID )
1789 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1790 _PTR(Study) aStudy = SMESH::getStudy();
1792 SALOME_ListIO selected;
1793 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1794 aSel->selectedObjects( selected );
1796 if ( !selected.IsEmpty() ) {
1797 SALOME_ListIteratorOfListIO It(selected);
1798 for ( ; It.More(); It.Next())
1800 Handle(SALOME_InteractiveObject) anIO = It.Value();
1801 if ( !anIO.IsNull() ) {
1802 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1804 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1805 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1806 if ( !anIDSrc->_is_nil() ) {
1807 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1808 if (( !anActor && selected.Extent() == 1 ) &&
1809 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1811 anActor->SetControlMode( aControl );
1812 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1813 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1817 if ( anActor->GetControlMode() != aControl )
1818 anActor->SetControlMode( aControl );
1819 QString functorName = functorToString( anActor->GetFunctor() );
1820 smIdType anEntitiesCount = anActor->GetNumberControlEntities();
1821 if (anEntitiesCount >= 0)
1822 functorName = functorName + ": " + QString::number(anEntitiesCount);
1823 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1824 SMESH::RepaintCurrentView();
1825 #ifndef DISABLE_PLOT2DVIEWER
1826 if ( anActor->GetPlot2Histogram() ) {
1827 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1828 QString aHistogramName("%1 : %2");
1829 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1830 aHistogram->setName( aHistogramName );
1831 aHistogram->setHorTitle( functorName );
1832 SMESH::ProcessIn2DViewers( anActor );
1844 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1845 SMESH::MeshObjectType theType,
1846 const QString theInTypeName,
1847 QString & theOutTypeName)
1849 SMESH_TypeFilter aTypeFilter( theType );
1851 if ( !theIO.IsNull() )
1853 entry = theIO->getEntry();
1854 LightApp_DataOwner owner( entry );
1855 if ( aTypeFilter.isOk( &owner )) {
1856 theOutTypeName = theInTypeName;
1864 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1866 _PTR(Study) aStudy = SMESH::getStudy();
1867 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1869 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1870 CORBA::String_var anID = aSComp->GetID().c_str();
1871 if ( !strcmp(anID.in(),theIO->getEntry()) )
1877 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1878 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1879 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1880 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1881 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1889 // QString CheckHomogeneousSelection()
1891 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1892 // SALOME_ListIO selected;
1894 // aSel->selectedObjects( selected );
1896 // QString RefType = CheckTypeObject(selected.First());
1897 // SALOME_ListIteratorOfListIO It(selected);
1898 // for ( ; It.More(); It.Next())
1900 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1901 // QString Type = CheckTypeObject(IObject);
1902 // if ( Type.compare(RefType) != 0 )
1903 // return "Heterogeneous Selection";
1909 uint randomize( uint size )
1911 static bool initialized = false;
1912 if ( !initialized ) {
1913 qsrand( QDateTime::currentDateTime().toTime_t() );
1917 v = uint( (double)( v ) / RAND_MAX * size );
1918 v = qMax( uint(0), qMin ( v, size-1 ) );
1924 void SMESHGUI::OnEditDelete()
1926 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1927 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1928 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1930 _PTR(Study) aStudy = SMESH::getStudy();
1931 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1932 _PTR(GenericAttribute) anAttr;
1933 _PTR(AttributeIOR) anIOR;
1935 const int objectCountLimit = 30; // PAL23599
1936 int objectCount = 0;
1938 QString aParentComponent = QString::null;
1940 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1942 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1943 if ( anIO.IsNull() ) continue;
1945 QString father = "unknown", name;
1947 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1949 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1950 // check if object is reference
1951 _PTR(SObject) aRefSObj;
1952 if ( aSO->ReferencedObject( aRefSObj ) ) {
1953 name = QString::fromStdString ( aRefSObj->GetName() );
1954 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1957 name = anIO->getName();
1960 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1961 aNameList.append("\n - ");
1962 aNameList.append( name );
1965 if( aParentComponent.isNull() )
1966 aParentComponent = father;
1967 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1968 aParentComponent = "";
1970 if ( objectCount >= objectCountLimit )
1971 aNameList.append("\n - ...");
1973 if ( objectCount == 0 )
1974 return; // No Valid Objects Selected
1976 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1977 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1978 QObject::tr("ERR_ERROR"),
1979 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1982 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1983 if (SUIT_MessageBox::warning
1984 (SMESHGUI::desktop(),
1985 QObject::tr("SMESH_WRN_WARNING"),
1986 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1987 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1988 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1991 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1993 // Put one level of sub-objects of the selected SO's into a list
1994 // in order to get objects inside folders like "Assigned Algorithms"
1995 std::list< _PTR(SObject) > listSO;
1996 SALOME_ListIteratorOfListIO It(selected);
1997 for( ; It.More(); It.Next()) // loop on selected IO's
1999 Handle(SALOME_InteractiveObject) IObject = It.Value();
2000 if(IObject->hasEntry()) {
2001 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2003 // disable removal of "SMESH" component object
2004 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2006 if ( engineIOR() == anIOR->Value().c_str() )
2009 //Check the referenced object
2010 _PTR(SObject) aRefSObject;
2011 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2012 aSO = aRefSObject; // Delete main Object instead of reference
2014 listSO.push_back( aSO );
2016 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2017 for (it->InitEx(false); it->More(); it->Next())
2018 listSO.push_back( it->Value() );
2021 // Check if none of objects to delete is referred from outside
2022 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2023 std::vector< _PTR(SObject) > subSO;
2024 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2026 _PTR(SObject) SO = *ritSO;
2027 if ( !SO ) continue;
2029 int nbChildren = SO->GetLastChildTag();
2031 subSO.reserve( 1 + nbChildren );
2032 subSO.push_back( SO );
2033 if ( nbChildren > 0 )
2035 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2036 for ( it->InitEx( true ); it->More(); it->Next() )
2037 subSO.push_back( it->Value() );
2039 for ( size_t i = 0; i < subSO.size(); ++i )
2041 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2042 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2043 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2044 std::string type = aComponent->ComponentDataType();
2045 if ( type != "SMESH" )
2047 SUIT_MessageBox::warning( anApp->desktop(),
2048 QObject::tr("WRN_WARNING"),
2049 QObject::tr("DEP_OBJECT") );
2050 return; // outside SMESH, there is an object depending on a SMESH object
2056 // Treat SO's in the list starting from the back
2057 aStudyBuilder->NewCommand(); // There is a transaction
2058 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2060 _PTR(SObject) SO = *ritSO;
2061 if ( !SO ) continue;
2062 std::string anEntry = SO->GetID();
2064 /** Erase graphical object and remove all its data **/
2065 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2066 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2068 /** Remove an object from data structures **/
2069 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2070 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2071 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2072 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2073 aMesh->RemoveGroup( aGroup );
2075 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2076 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2077 aMesh->RemoveSubMesh( aSubMesh );
2080 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2081 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2082 QString objType = CheckTypeObject(IObject);
2083 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2084 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2085 aStudyBuilder->RemoveObjectWithChildren( SO );
2087 else {// default action: remove SObject from the study
2088 // Find Sub-Meshes and Group and delete corresopning visual objects and actors
2089 _PTR(ChildIterator) it1 = aStudy->NewChildIterator(SO);
2090 for (it1->InitEx(false); it1->More(); it1->Next()) {
2091 _PTR(SObject) SObj = it1->Value();
2092 if (!SObj) continue;
2093 if (SObj->FindAttribute(anAttr, "AttributeIOR")) {
2094 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(SMESH::SObjectToObject(SObj));
2095 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow(SMESH::SObjectToObject(SObj));
2096 if (!aGroup->_is_nil() || !aSubMesh->_is_nil()) {
2097 SMESH::RemoveVisualObjectWithActors(SObj->GetID().c_str(), true);
2101 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2102 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2104 aStudyBuilder->RemoveObjectWithChildren( SO );
2108 } /* listSO back loop */
2110 aStudyBuilder->CommitCommand();
2112 /* Clear any previous selection */
2114 aSel->setSelectedObjects( l1 );
2116 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2120 SMESHGUI_EXPORT CAM_Module* createModule()
2122 return new SMESHGUI();
2125 SMESHGUI_EXPORT char* getModuleVersion() {
2126 return (char*)SMESH_VERSION_STR;
2130 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2132 //=============================================================================
2136 //=============================================================================
2137 SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
2139 if ( CORBA::is_nil( myComponentSMESH ) )
2141 CORBA::Boolean anIsEmbeddedMode;
2142 SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
2143 if( dynamic_cast<SALOME_NamingService *>(ns) )
2144 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2147 Engines::EngineComponent_var comp = RetrieveSMESHInstance();
2148 myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
2151 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2153 // 0019923: EDF 765 SMESH : default values of hypothesis
2154 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2155 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2156 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2157 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2158 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2160 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2161 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2162 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2164 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2165 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2169 myActiveDialogBox = 0;
2170 myFilterLibraryDlg = 0;
2174 myEventCallbackCommand = vtkCallbackCommand::New();
2175 myEventCallbackCommand->Delete();
2176 myEventCallbackCommand->SetClientData( this );
2177 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2180 /* load resources for all available meshers */
2181 SMESH::InitAvailableHypotheses();
2184 //=============================================================================
2188 //=============================================================================
2189 SMESHGUI::~SMESHGUI()
2193 //=============================================================================
2197 //=============================================================================
2198 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2200 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2202 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2207 //=============================================================================
2211 //=============================================================================
2212 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2214 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2218 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2219 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2220 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2221 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2222 return autoUpdate && !exceeded;
2225 //=============================================================================
2229 //=============================================================================
2230 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2231 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2233 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2237 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2238 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2239 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2241 SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
2242 long nbOdElems = info[SMDSEntity_0D];
2243 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2244 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2245 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2246 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2247 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2248 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2249 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2250 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2251 info[SMDSEntity_Polyhedra] +
2252 info[SMDSEntity_Hexagonal_Prism];
2253 long nbBalls = info[SMDSEntity_Ball];
2255 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2256 *nbElements = requestedSize;
2258 *entities = SMESH_Actor::eAllEntity;
2261 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2263 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2265 if ( incrementalLimit ) {
2268 if ( nbOdElems > 0 ) {
2269 if ( total + nbOdElems > updateLimit ) {
2270 *entities = *entities & ~SMESH_Actor::e0DElements;
2271 *hidden = *hidden | SMESH_Actor::e0DElements;
2278 if ( nbEdges > 0 ) {
2279 if ( total + nbEdges > updateLimit ) {
2280 *entities = *entities & ~SMESH_Actor::eEdges;
2281 *hidden = *hidden | SMESH_Actor::eEdges;
2288 if ( nbFaces > 0 ) {
2289 if ( total + nbFaces > updateLimit ) {
2290 *entities = *entities & ~SMESH_Actor::eFaces;
2291 *hidden = *hidden | SMESH_Actor::eFaces;
2298 if ( nbVolumes > 0 ) {
2299 if ( total + nbVolumes > updateLimit ) {
2300 *entities = *entities & ~SMESH_Actor::eVolumes;
2301 *hidden = *hidden | SMESH_Actor::eVolumes;
2308 if ( nbBalls > 0 ) {
2309 if ( total + nbBalls > updateLimit ) {
2310 *entities = *entities & ~SMESH_Actor::eBallElem;
2311 *hidden = *hidden | SMESH_Actor::eBallElem;
2319 return autoUpdate && !exceeded;
2322 //=============================================================================
2326 //=============================================================================
2327 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2329 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2332 //=============================================================================
2336 //=============================================================================
2337 SMESHGUI* SMESHGUI::GetSMESHGUI()
2339 SMESHGUI* smeshMod = 0;
2340 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2343 CAM_Module* module = app->module( "Mesh" );
2344 smeshMod = dynamic_cast<SMESHGUI*>( module );
2352 Standard_EXPORT SMESHGUI* GetComponentGUI()
2354 return SMESHGUI::GetSMESHGUI();
2358 //=============================================================================
2362 //=============================================================================
2363 void SMESHGUI::SetState(int aState)
2368 //=============================================================================
2372 //=============================================================================
2373 void SMESHGUI::ResetState()
2378 //=============================================================================
2382 //=============================================================================
2383 void SMESHGUI::EmitSignalDeactivateDialog()
2385 emit SignalDeactivateActiveDialog();
2388 //=============================================================================
2392 //=============================================================================
2393 void SMESHGUI::EmitSignalStudyFrameChanged()
2395 emit SignalStudyFrameChanged();
2398 //=============================================================================
2402 //=============================================================================
2403 void SMESHGUI::EmitSignalCloseAllDialogs()
2405 emit SignalCloseAllDialogs();
2408 //=============================================================================
2412 //=============================================================================
2413 void SMESHGUI::EmitSignalVisibilityChanged()
2415 emit SignalVisibilityChanged();
2418 //=============================================================================
2422 //=============================================================================
2423 void SMESHGUI::EmitSignalCloseView()
2425 emit SignalCloseView();
2428 //=============================================================================
2432 //=============================================================================
2433 void SMESHGUI::EmitSignalActivatedViewManager()
2435 emit SignalActivatedViewManager();
2438 //=============================================================================
2442 //=============================================================================
2443 QDialog *SMESHGUI::GetActiveDialogBox()
2445 return myActiveDialogBox;
2448 //=============================================================================
2452 //=============================================================================
2453 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2455 myActiveDialogBox = (QDialog *) aDlg;
2459 //=============================================================================
2463 //=============================================================================
2464 SUIT_Desktop* SMESHGUI::desktop()
2466 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2468 return app->desktop();
2473 //=============================================================================
2477 //=============================================================================
2478 SalomeApp_Study* SMESHGUI::activeStudy()
2480 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2482 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2487 //=============================================================================
2491 //=============================================================================
2492 void SMESHGUI::Modified( bool theIsUpdateActions )
2494 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2495 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2496 appStudy->Modified();
2497 if( theIsUpdateActions )
2498 app->updateActions();
2503 //=============================================================================
2507 //=============================================================================
2508 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2510 /* Here the position is on the bottom right corner - 10 */
2511 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2513 SUIT_Desktop *PP = desktop();
2514 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2515 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2520 * \brief Verifies whether study of operation is locked
2521 * \param theMess - specifies whether message box must be shown if study is locked
2522 * \return State of study.
2524 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2525 * is locked when corresponding message box appears
2527 bool SMESHGUI::isStudyLocked( bool theMessage )
2529 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2532 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2533 QObject::tr( "WRN_WARNING" ),
2534 QObject::tr( "WRN_STUDY_LOCKED" ) );
2540 //=============================================================================
2544 //=============================================================================
2545 bool SMESHGUI::OnGUIEvent( int theCommandID )
2547 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2551 SUIT_ResourceMgr* mgr = resourceMgr();
2555 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2556 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2558 //QAction* act = action( theCommandID );
2560 switch (theCommandID) {
2561 case SMESHOp::OpDelete:
2562 if(isStudyLocked()) break;
2565 case SMESHOp::OpImportDAT:
2566 case SMESHOp::OpImportUNV:
2567 case SMESHOp::OpImportMED:
2568 case SMESHOp::OpImportSTL:
2569 case SMESHOp::OpImportCGNS:
2570 case SMESHOp::OpImportGMF:
2571 case SMESHOp::OpPopupImportDAT:
2572 case SMESHOp::OpPopupImportUNV:
2573 case SMESHOp::OpPopupImportMED:
2574 case SMESHOp::OpPopupImportSTL:
2575 case SMESHOp::OpPopupImportCGNS:
2576 case SMESHOp::OpPopupImportGMF:
2578 if(isStudyLocked()) break;
2579 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2583 case SMESHOp::OpFileInformation:
2585 SALOME_ListIO selected;
2586 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2588 aSel->selectedObjects( selected );
2589 if( selected.Extent() )
2591 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2592 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2593 if ( !aMesh->_is_nil() )
2595 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2601 case SMESHOp::OpExportDAT:
2602 case SMESHOp::OpExportMED:
2603 case SMESHOp::OpExportUNV:
2604 case SMESHOp::OpExportSTL:
2605 case SMESHOp::OpExportCGNS:
2606 case SMESHOp::OpExportGMF:
2607 case SMESHOp::OpPopupExportDAT:
2608 case SMESHOp::OpPopupExportMED:
2609 case SMESHOp::OpPopupExportUNV:
2610 case SMESHOp::OpPopupExportSTL:
2611 case SMESHOp::OpPopupExportCGNS:
2612 case SMESHOp::OpPopupExportGMF:
2614 ::ExportMeshToFile(theCommandID);
2618 case SMESHOp::OpReset: // SCALAR BAR
2620 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2621 SALOME_ListIO selected;
2623 aSel->selectedObjects( selected );
2625 SALOME_ListIteratorOfListIO it(selected);
2626 for( ; it.More(); it.Next()) {
2627 Handle(SALOME_InteractiveObject) anIO = it.Value();
2628 if( anIO->hasEntry() ) {
2629 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2630 anActor->SetControlMode( SMESH_Actor::eNone );
2631 #ifndef DISABLE_PLOT2DVIEWER
2632 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2634 anActor->UpdateFilter();
2638 SMESH::UpdateView();
2641 case SMESHOp::OpScalarBarProperties:
2643 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2646 case SMESHOp::OpShowScalarBar:
2648 // show/hide scalar bar
2649 ::ShowElement(theCommandID);
2652 case SMESHOp::OpSaveDistribution:
2654 // dump control distribution data to the text file
2655 ::SaveDistribution();
2659 case SMESHOp::OpShowDistribution:
2661 // show/hide distribution
2662 ::ShowElement(theCommandID);
2666 #ifndef DISABLE_PLOT2DVIEWER
2667 case SMESHOp::OpPlotDistribution:
2669 // plot distribution
2670 ::PlotDistribution();
2676 case SMESHOp::OpAutoColor:
2680 case SMESHOp::OpDisableAutoColor:
2681 ::DisableAutoColor();
2684 case SMESHOp::OpClipping:
2685 case SMESHOp::OpTransparency:
2686 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2689 case SMESHOp::OpDMWireframe:
2690 case SMESHOp::OpDMShading:
2691 case SMESHOp::OpDMNodes:
2692 case SMESHOp::OpDMShrink:
2693 ::SetDisplayMode(theCommandID, myMarkerMap);
2696 //2D quadratic representation
2697 case SMESHOp::OpRepresentationLines:
2698 case SMESHOp::OpRepresentationArcs:
2699 ::SetDisplayMode(theCommandID, myMarkerMap);
2703 case SMESHOp::OpDE0DElements:
2704 case SMESHOp::OpDEEdges:
2705 case SMESHOp::OpDEFaces:
2706 case SMESHOp::OpDEVolumes:
2707 case SMESHOp::OpDEBalls:
2708 case SMESHOp::OpDEAllEntity:
2709 ::SetDisplayEntity(theCommandID);
2712 // Choose entities to be displayed
2713 case SMESHOp::OpDEChoose:
2715 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2719 case SMESHOp::OpOrientationOnFaces:
2721 SUIT_OverrideCursor wc;
2722 LightApp_SelectionMgr* mgr = selectionMgr();
2723 SALOME_ListIO selected; mgr->selectedObjects( selected );
2725 SALOME_ListIteratorOfListIO it(selected);
2726 for( ; it.More(); it.Next()) {
2727 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2728 if(anIObject->hasEntry()) {
2729 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2730 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2737 case SMESHOp::OpUpdate:
2739 if(isStudyLocked()) break;
2740 SUIT_OverrideCursor wc;
2743 SMESH::UpdateView();
2745 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2746 SMESH::OnVisuException();
2748 catch (...) { // PAL16774 (Crash after display of many groups)
2749 SMESH::OnVisuException();
2753 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2754 aSel->selectedObjects( l );
2755 aSel->setSelectedObjects( l );
2759 case SMESHOp::OpHide:
2760 case SMESHOp::OpShow:
2761 case SMESHOp::OpShowOnly:
2763 SUIT_OverrideCursor wc;
2764 SMESH::EDisplaing anAction;
2765 switch (theCommandID) {
2766 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2767 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2768 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2771 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2772 SALOME_ListIO sel_objects, to_process;
2774 aSel->selectedObjects( sel_objects );
2776 if ( theCommandID==SMESHOp::OpShowOnly )
2778 //MESSAGE("anAction = SMESH::eDisplayOnly");
2779 startOperation( myEraseAll );
2782 extractContainers( sel_objects, to_process );
2787 SALOME_ListIteratorOfListIO It( to_process );
2788 for ( ; It.More(); It.Next())
2790 Handle(SALOME_InteractiveObject) IOS = It.Value();
2791 if ( IOS->hasEntry() )
2793 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2794 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2795 break; // PAL16774 (Crash after display of many groups)
2797 if (anAction == SMESH::eDisplayOnly)
2798 anAction = SMESH::eDisplay;
2803 // PAL13338 + PAL15161 -->
2804 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2805 SMESH::UpdateView();
2806 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2808 // PAL13338 + PAL15161 <--
2810 catch (...) { // PAL16774 (Crash after display of many groups)
2811 SMESH::OnVisuException();
2814 if (anAction == SMESH::eErase) {
2816 aSel->setSelectedObjects( l1 );
2819 aSel->setSelectedObjects( to_process );
2821 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2822 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2823 vtkwnd->GetRenderer()->AdjustActors();
2828 case SMESHOp::OpNode:
2830 if(isStudyLocked()) break;
2833 EmitSignalDeactivateDialog();
2835 ( new SMESHGUI_NodesDlg( this ) )->show();
2838 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2843 case SMESHOp::OpEditMeshOrSubMesh:
2844 case SMESHOp::OpEditMesh:
2845 case SMESHOp::OpEditSubMesh:
2846 case SMESHOp::OpMeshOrder:
2847 case SMESHOp::OpCreateSubMesh:
2848 if ( warnOnGeomModif() )
2849 break; // action forbidden as geometry modified
2851 case SMESHOp::OpCreateMesh:
2852 case SMESHOp::OpCompute:
2853 case SMESHOp::OpComputeSubMesh:
2854 case SMESHOp::OpPreCompute:
2855 case SMESHOp::OpEvaluate:
2856 case SMESHOp::OpShowErrors:
2857 startOperation( theCommandID );
2859 case SMESHOp::OpRecompute:
2861 if ( isStudyLocked() )
2863 SALOME_ListIO selected;
2864 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2865 sel->selectedObjects( selected );
2866 if ( selected.Extent() == 1 ) {
2867 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2868 if ( !aMesh->_is_nil() )
2870 startOperation( SMESHOp::OpCompute );
2874 case SMESHOp::OpCopyMesh:
2876 if (isStudyLocked()) break;
2877 EmitSignalDeactivateDialog();
2878 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2881 case SMESHOp::OpBuildCompoundMesh:
2883 if (isStudyLocked()) break;
2884 EmitSignalDeactivateDialog();
2885 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2889 case SMESHOp::OpDiagonalInversion:
2890 case SMESHOp::OpUnionOfTwoTriangle:
2894 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2898 if ( isStudyLocked() )
2900 if ( warnOnGeomModif() )
2901 break; // action forbidden as geometry modified
2903 /*Standard_Boolean aRes;
2904 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2905 if ( aMesh->_is_nil() )
2907 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2908 tr( "SMESH_BAD_SELECTION" ) );
2912 EmitSignalDeactivateDialog();
2913 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2914 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2916 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2919 case SMESHOp::OpOrientation:
2920 case SMESHOp::OpUnionOfTriangles:
2921 case SMESHOp::OpCuttingOfQuadrangles:
2922 case SMESHOp::OpSplitVolumes:
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 EmitSignalDeactivateDialog();
2936 SMESHGUI_MultiEditDlg* aDlg = NULL;
2937 if ( theCommandID == SMESHOp::OpOrientation )
2938 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2939 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2940 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2941 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2942 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2944 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2949 case SMESHOp::OpSmoothing:
2951 if(isStudyLocked()) break;
2952 if ( warnOnGeomModif() )
2953 break; // action forbidden as geometry modified
2955 EmitSignalDeactivateDialog();
2956 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2959 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2963 case SMESHOp::OpExtrusion:
2965 if (isStudyLocked()) break;
2966 if ( warnOnGeomModif() )
2967 break; // action forbidden as geometry modified
2969 EmitSignalDeactivateDialog();
2970 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2972 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2976 case SMESHOp::OpExtrusionAlongAPath:
2978 if (isStudyLocked()) break;
2979 if ( warnOnGeomModif() )
2980 break; // action forbidden as geometry modified
2982 EmitSignalDeactivateDialog();
2983 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2985 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2989 case SMESHOp::OpRevolution:
2991 if(isStudyLocked()) break;
2992 if ( warnOnGeomModif() )
2993 break; // action forbidden as geometry modified
2995 EmitSignalDeactivateDialog();
2996 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2999 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3003 case SMESHOp::OpPatternMapping:
3005 if ( isStudyLocked() )
3007 if ( warnOnGeomModif() )
3008 break; // action forbidden as geometry modified
3011 EmitSignalDeactivateDialog();
3012 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3015 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3019 // Adaptation - begin
3020 #ifndef DISABLE_MG_ADAPT
3021 case SMESHOp::OpMGAdapt:
3023 if ( isStudyLocked() )
3025 EmitSignalDeactivateDialog();
3027 SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
3028 bool isCreation = false;
3029 ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
3033 #ifndef DISABLE_HOMARD_ADAPT
3034 case SMESHOp::OpHomardAdapt:
3036 if ( isStudyLocked() )
3038 EmitSignalDeactivateDialog();
3040 SALOME::GenericObj_wrap< SMESHHOMARD::HOMARD_Gen > homardGen;
3042 homardGen = GetSMESHGen()->CreateHOMARD_ADAPT();
3044 catch ( const SALOME::SALOME_Exception& S_ex ) {
3045 SUIT_MessageBox::critical(SMESHGUI::desktop(),
3046 QObject::tr("SMESH_ERROR"),
3047 QObject::tr(S_ex.details.text.in()));
3049 if (!homardGen->_is_nil()) {
3050 SMESHGUI_HomardAdaptDlg *aDlg = new SMESHGUI_HomardAdaptDlg(homardGen);
3057 case SMESHOp::OpSplitBiQuadratic:
3058 case SMESHOp::OpConvertMeshToQuadratic:
3059 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3060 case SMESHOp::OpReorientFaces:
3061 case SMESHOp::OpCreateGeometryGroup:
3063 if ( warnOnGeomModif() )
3064 break; // action forbidden as geometry modified
3065 startOperation( theCommandID );
3068 case SMESHOp::OpCreateGroup:
3072 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3076 if(isStudyLocked()) break;
3077 if ( warnOnGeomModif() )
3078 break; // action forbidden as geometry modified
3079 EmitSignalDeactivateDialog();
3080 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3082 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3083 SALOME_ListIO selected;
3085 aSel->selectedObjects( selected );
3087 int nbSel = selected.Extent();
3089 // check if mesh is selected
3090 aMesh = SMESH::GetMeshByIO( selected.First() );
3092 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3097 case SMESHOp::OpConstructGroup:
3101 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3105 if(isStudyLocked()) break;
3106 if ( warnOnGeomModif() )
3107 break; // action forbidden as geometry modified
3108 EmitSignalDeactivateDialog();
3110 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3111 SALOME_ListIO selected;
3113 aSel->selectedObjects( selected );
3115 int nbSel = selected.Extent();
3117 // check if submesh is selected
3118 Handle(SALOME_InteractiveObject) IObject = selected.First();
3119 if (IObject->hasEntry()) {
3120 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3122 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3123 if (!aSubMesh->_is_nil()) {
3125 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3126 // get submesh elements list by types
3127 SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3128 SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3129 SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3130 SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3131 // create group for each type o elements
3132 QString aName = IObject->getName();
3133 QStringList anEntryList;
3134 if (aNodes->length() > 0) {
3135 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3136 aGroup->Add(aNodes.inout());
3137 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3138 anEntryList.append( aSObject->GetID().c_str() );
3140 if (aEdges->length() > 0) {
3141 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3142 aGroup->Add(aEdges.inout());
3143 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3144 anEntryList.append( aSObject->GetID().c_str() );
3146 if (aFaces->length() > 0) {
3147 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3148 aGroup->Add(aFaces.inout());
3149 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3150 anEntryList.append( aSObject->GetID().c_str() );
3152 if (aVolumes->length() > 0) {
3153 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3154 aGroup->Add(aVolumes.inout());
3155 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3156 anEntryList.append( aSObject->GetID().c_str() );
3159 anApp->browseObjects( anEntryList );
3161 catch(const SALOME::SALOME_Exception & S_ex){
3162 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3169 SUIT_MessageBox::warning(desktop(),
3170 tr("SMESH_WRN_WARNING"),
3171 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3176 case SMESHOp::OpEditGroup:
3180 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3184 if(isStudyLocked()) break;
3185 if ( warnOnGeomModif() )
3186 break; // action forbidden as geometry modified
3187 EmitSignalDeactivateDialog();
3189 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3190 SALOME_ListIO selected;
3192 aSel->selectedObjects( selected );
3194 SALOME_ListIteratorOfListIO It (selected);
3195 int nbSelectedGroups = 0;
3196 for ( ; It.More(); It.Next() )
3198 SMESH::SMESH_GroupBase_var aGroup =
3199 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3200 if (!aGroup->_is_nil()) {
3202 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3206 if (nbSelectedGroups == 0)
3208 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3214 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3216 if(isStudyLocked()) break;
3217 if (myState == 800) {
3218 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3219 if (aDlg) aDlg->onAdd();
3224 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3226 if(isStudyLocked()) break;
3227 if (myState == 800) {
3228 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3229 if (aDlg) aDlg->onRemove();
3234 case SMESHOp::OpEditGeomGroupAsGroup:
3238 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3242 if(isStudyLocked()) break;
3243 EmitSignalDeactivateDialog();
3245 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3246 SALOME_ListIO selected;
3248 aSel->selectedObjects( selected );
3250 SALOME_ListIteratorOfListIO It (selected);
3251 for ( ; It.More(); It.Next() )
3253 SMESH::SMESH_GroupOnGeom_var aGroup =
3254 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3255 if (!aGroup->_is_nil()) {
3256 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3261 SMESH::SMESH_GroupOnFilter_var aGroup =
3262 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3263 if (!aGroup->_is_nil()) {
3264 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3272 case SMESHOp::OpUnionGroups:
3273 case SMESHOp::OpIntersectGroups:
3274 case SMESHOp::OpCutGroups:
3278 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3282 if ( isStudyLocked() )
3284 if ( warnOnGeomModif() )
3285 break; // action forbidden as geometry modified
3287 EmitSignalDeactivateDialog();
3289 SMESHGUI_GroupOpDlg* aDlg = 0;
3290 if ( theCommandID == SMESHOp::OpUnionGroups )
3291 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3292 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3293 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3295 aDlg = new SMESHGUI_CutGroupsDlg( this );
3302 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3304 if ( isStudyLocked() )
3306 if ( warnOnGeomModif() )
3307 break; // action forbidden as geometry modified
3309 EmitSignalDeactivateDialog();
3310 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3316 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3318 if ( isStudyLocked() )
3320 if ( warnOnGeomModif() )
3321 break; // action forbidden as geometry modified
3323 EmitSignalDeactivateDialog();
3324 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3330 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3334 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3338 if ( isStudyLocked() )
3341 EmitSignalDeactivateDialog();
3343 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3347 case SMESHOp::OpMeshInformation:
3348 case SMESHOp::OpWhatIs:
3350 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3351 EmitSignalDeactivateDialog();
3352 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3353 SALOME_ListIO selected;
3355 aSel->selectedObjects( selected );
3357 if ( selected.Extent() > 1 ) { // a dlg for each IO
3358 SALOME_ListIteratorOfListIO It( selected );
3359 for ( ; It.More(); It.Next() ) {
3360 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3361 dlg->showInfo( It.Value() );
3366 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3372 case SMESHOp::OpFindElementByPoint:
3374 startOperation( theCommandID );
3378 case SMESHOp::OpEditHypothesis:
3380 if(isStudyLocked()) break;
3381 if ( warnOnGeomModif() )
3382 break; // action forbidden as geometry modified
3384 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3385 SALOME_ListIO selected;
3387 aSel->selectedObjects( selected );
3389 int nbSel = selected.Extent();
3392 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3393 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3395 if ( !aHypothesis->_is_nil() )
3397 SMESHGUI_GenericHypothesisCreator* aCreator =
3398 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3401 // set geometry of mesh and sub-mesh to aCreator
3402 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3403 if ( selected.Extent() == 1 )
3405 QString subGeomID, meshGeomID;
3406 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3407 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3409 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3410 aCreator->setShapeEntry( subGeomID );
3411 aCreator->setMainShapeEntry( meshGeomID );
3415 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3425 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3427 if(isStudyLocked()) break;
3428 if ( warnOnGeomModif() )
3429 break; // action forbidden as geometry modified
3430 SUIT_OverrideCursor wc;
3432 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3433 SALOME_ListIO selected;
3435 aSel->selectedObjects( selected, QString::null, false );
3437 SALOME_ListIteratorOfListIO It(selected);
3438 for (int i = 0; It.More(); It.Next(), i++) {
3439 Handle(SALOME_InteractiveObject) IObject = It.Value();
3440 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3443 aSel->setSelectedObjects( l1 );
3448 case SMESHOp::OpElem0D:
3449 case SMESHOp::OpBall:
3450 case SMESHOp::OpEdge:
3451 case SMESHOp::OpTriangle:
3452 case SMESHOp::OpQuadrangle:
3453 case SMESHOp::OpPolygon:
3454 case SMESHOp::OpTetrahedron:
3455 case SMESHOp::OpHexahedron:
3456 case SMESHOp::OpPentahedron:
3457 case SMESHOp::OpPyramid:
3458 case SMESHOp::OpHexagonalPrism:
3460 if(isStudyLocked()) break;
3461 if ( warnOnGeomModif() )
3462 break; // action forbidden as geometry modified
3464 EmitSignalDeactivateDialog();
3465 SMDSAbs_EntityType type = SMDSEntity_Edge;
3466 switch (theCommandID) {
3467 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3468 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3469 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3470 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3471 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3472 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3473 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3474 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3475 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3476 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3479 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3482 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3486 case SMESHOp::OpPolyhedron:
3488 if(isStudyLocked()) break;
3489 if ( warnOnGeomModif() )
3490 break; // action forbidden as geometry modified
3492 EmitSignalDeactivateDialog();
3493 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3496 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3500 case SMESHOp::OpQuadraticEdge:
3501 case SMESHOp::OpQuadraticTriangle:
3502 case SMESHOp::OpBiQuadraticTriangle:
3503 case SMESHOp::OpQuadraticQuadrangle:
3504 case SMESHOp::OpBiQuadraticQuadrangle:
3505 case SMESHOp::OpQuadraticPolygon:
3506 case SMESHOp::OpQuadraticTetrahedron:
3507 case SMESHOp::OpQuadraticPyramid:
3508 case SMESHOp::OpQuadraticPentahedron:
3509 case SMESHOp::OpBiQuadraticPentahedron:
3510 case SMESHOp::OpQuadraticHexahedron:
3511 case SMESHOp::OpTriQuadraticHexahedron:
3513 if(isStudyLocked()) break;
3514 if ( warnOnGeomModif() )
3515 break; // action forbidden as geometry modified
3517 EmitSignalDeactivateDialog();
3518 SMDSAbs_EntityType type = SMDSEntity_Last;
3520 switch (theCommandID) {
3521 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3522 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3523 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3524 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3525 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3526 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3527 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3528 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3529 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3530 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3531 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3532 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3535 if ( type != SMDSEntity_Last )
3536 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3539 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3540 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3544 case SMESHOp::OpRemoveNodes:
3546 if(isStudyLocked()) break;
3547 if ( warnOnGeomModif() )
3548 break; // action forbidden as geometry modified
3550 EmitSignalDeactivateDialog();
3551 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3554 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3555 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3559 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3561 if(isStudyLocked()) break;
3562 if ( warnOnGeomModif() )
3563 break; // action forbidden as geometry modified
3565 EmitSignalDeactivateDialog();
3566 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3570 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3571 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3575 case SMESHOp::OpClearMesh: {
3577 if(isStudyLocked()) break;
3578 if ( warnOnGeomModif() )
3579 break; // action forbidden as geometry modified
3581 SALOME_ListIO selected;
3582 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3583 aSel->selectedObjects( selected );
3585 SUIT_OverrideCursor wc;
3586 SALOME_ListIteratorOfListIO It (selected);
3587 for ( ; It.More(); It.Next() )
3589 Handle(SALOME_InteractiveObject) IOS = It.Value();
3590 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3591 if ( aMesh->_is_nil()) continue;
3594 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3595 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3596 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3597 // hide groups and submeshes
3598 _PTR(ChildIterator) anIter =
3599 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3600 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3602 _PTR(SObject) so = anIter->Value();
3603 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3606 catch (const SALOME::SALOME_Exception& S_ex){
3608 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3612 SMESH::UpdateView();
3616 case SMESHOp::OpRemoveOrphanNodes:
3618 if(isStudyLocked()) break;
3619 if ( warnOnGeomModif() )
3620 break; // action forbidden as geometry modified
3621 SALOME_ListIO selected;
3622 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3623 aSel->selectedObjects( selected );
3624 if ( selected.Extent() == 1 ) {
3625 Handle(SALOME_InteractiveObject) anIO = selected.First();
3626 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3627 if ( !aMesh->_is_nil() ) {
3628 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3629 tr( "SMESH_WARNING" ),
3630 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3631 SUIT_MessageBox::Yes |
3632 SUIT_MessageBox::No,
3633 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3636 SUIT_OverrideCursor wc;
3637 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3638 smIdType removed = aMeshEditor->RemoveOrphanNodes();
3639 SUIT_MessageBox::information(SMESHGUI::desktop(),
3640 tr("SMESH_INFORMATION"),
3641 tr("NB_NODES_REMOVED").arg(removed));
3642 if ( removed > 0 ) {
3643 SMESH::UpdateView();
3644 SMESHGUI::Modified();
3647 catch (const SALOME::SALOME_Exception& S_ex) {
3648 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3657 case SMESHOp::OpRenumberingNodes:
3659 if(isStudyLocked()) break;
3660 if ( warnOnGeomModif() )
3661 break; // action forbidden as geometry modified
3663 EmitSignalDeactivateDialog();
3664 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3668 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3669 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3673 case SMESHOp::OpRenumberingElements:
3675 if(isStudyLocked()) break;
3676 if ( warnOnGeomModif() )
3677 break; // action forbidden as geometry modified
3679 EmitSignalDeactivateDialog();
3680 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3684 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3685 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3689 case SMESHOp::OpTranslation:
3691 if(isStudyLocked()) break;
3692 if ( warnOnGeomModif() )
3693 break; // action forbidden as geometry modified
3695 EmitSignalDeactivateDialog();
3696 ( new SMESHGUI_TranslationDlg( this ) )->show();
3699 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3700 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3704 case SMESHOp::OpRotation:
3706 if(isStudyLocked()) break;
3707 if ( warnOnGeomModif() )
3708 break; // action forbidden as geometry modified
3710 EmitSignalDeactivateDialog();
3711 ( new SMESHGUI_RotationDlg( this ) )->show();
3714 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3715 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3719 case SMESHOp::OpSymmetry:
3721 if(isStudyLocked()) break;
3722 if ( warnOnGeomModif() )
3723 break; // action forbidden as geometry modified
3725 EmitSignalDeactivateDialog();
3726 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3729 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3730 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3734 case SMESHOp::OpScale:
3736 if(isStudyLocked()) break;
3737 if ( warnOnGeomModif() )
3738 break; // action forbidden as geometry modified
3740 EmitSignalDeactivateDialog();
3741 ( new SMESHGUI_ScaleDlg( this ) )->show();
3744 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3745 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3750 case SMESHOp::OpOffset:
3752 if(isStudyLocked()) break;
3753 if ( warnOnGeomModif() )
3754 break; // action forbidden as geometry modified
3756 EmitSignalDeactivateDialog();
3757 ( new SMESHGUI_OffsetDlg( this ) )->show();
3760 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3761 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3766 case SMESHOp::OpSewing:
3768 if(isStudyLocked()) break;
3769 if ( warnOnGeomModif() )
3770 break; // action forbidden as geometry modified
3772 EmitSignalDeactivateDialog();
3773 ( new SMESHGUI_SewingDlg( this ) )->show();
3776 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3777 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3781 case SMESHOp::OpMergeNodes:
3783 if(isStudyLocked()) break;
3784 if ( warnOnGeomModif() )
3785 break; // action forbidden as geometry modified
3787 EmitSignalDeactivateDialog();
3788 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3791 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3792 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3796 case SMESHOp::OpMergeElements:
3798 if (isStudyLocked()) break;
3799 if ( warnOnGeomModif() )
3800 break; // action forbidden as geometry modified
3802 EmitSignalDeactivateDialog();
3803 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3805 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3806 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3811 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3812 if ( warnOnGeomModif() )
3813 break; // action forbidden as geometry modified
3814 startOperation( SMESHOp::OpMoveNode );
3817 case SMESHOp::OpDuplicateNodes:
3819 if(isStudyLocked()) break;
3820 if ( warnOnGeomModif() )
3821 break; // action forbidden as geometry modified
3823 EmitSignalDeactivateDialog();
3824 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3827 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3828 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3833 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3834 if ( warnOnGeomModif() )
3835 break; // action forbidden as geometry modified
3836 startOperation( SMESHOp::OpElem0DOnElemNodes );
3839 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3841 static QList<int> aTypes;
3842 if ( aTypes.isEmpty() )
3844 aTypes.append( SMESH::NODE );
3845 aTypes.append( SMESH::EDGE );
3846 aTypes.append( SMESH::FACE );
3847 aTypes.append( SMESH::VOLUME );
3849 if (!myFilterLibraryDlg)
3850 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3851 else if (myFilterLibraryDlg->isHidden())
3852 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3853 myFilterLibraryDlg->raise();
3857 case SMESHOp::OpFreeNode:
3858 case SMESHOp::OpEqualNode:
3859 case SMESHOp::OpNodeConnectivityNb:
3860 case SMESHOp::OpFreeEdge:
3861 case SMESHOp::OpFreeBorder:
3862 case SMESHOp::OpLength:
3863 case SMESHOp::OpConnection:
3864 case SMESHOp::OpEqualEdge:
3865 case SMESHOp::OpFreeFace:
3866 case SMESHOp::OpBareBorderFace:
3867 case SMESHOp::OpOverConstrainedFace:
3868 case SMESHOp::OpLength2D:
3869 case SMESHOp::OpDeflection2D:
3870 case SMESHOp::OpConnection2D:
3871 case SMESHOp::OpArea:
3872 case SMESHOp::OpTaper:
3873 case SMESHOp::OpAspectRatio:
3874 case SMESHOp::OpMinimumAngle:
3875 case SMESHOp::OpWarpingAngle:
3876 case SMESHOp::OpSkew:
3877 case SMESHOp::OpMaxElementLength2D:
3878 case SMESHOp::OpEqualFace:
3879 case SMESHOp::OpAspectRatio3D:
3880 case SMESHOp::OpVolume:
3881 case SMESHOp::OpMaxElementLength3D:
3882 case SMESHOp::OpBareBorderVolume:
3883 case SMESHOp::OpOverConstrainedVolume:
3884 case SMESHOp::OpEqualVolume:
3887 LightApp_SelectionMgr* mgr = selectionMgr();
3888 SALOME_ListIO selected; mgr->selectedObjects( selected );
3890 if( !selected.IsEmpty() ) {
3891 SUIT_OverrideCursor wc;
3892 ::Control( theCommandID );
3895 SUIT_MessageBox::warning(desktop(),
3896 tr( "SMESH_WRN_WARNING" ),
3897 tr( "SMESH_BAD_SELECTION" ) );
3901 SUIT_MessageBox::warning(desktop(),
3902 tr( "SMESH_WRN_WARNING" ),
3903 tr( "NOT_A_VTK_VIEWER" ) );
3906 case SMESHOp::OpOverallMeshQuality:
3907 OverallMeshQuality();
3909 case SMESHOp::OpNumberingNodes:
3911 SUIT_OverrideCursor wc;
3912 LightApp_SelectionMgr* mgr = selectionMgr();
3913 SALOME_ListIO selected; mgr->selectedObjects( selected );
3915 SALOME_ListIteratorOfListIO it(selected);
3916 for( ; it.More(); it.Next()) {
3917 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3918 if(anIObject->hasEntry()) {
3919 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3920 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3926 case SMESHOp::OpNumberingElements:
3928 SUIT_OverrideCursor wc;
3929 LightApp_SelectionMgr* mgr = selectionMgr();
3930 SALOME_ListIO selected; mgr->selectedObjects( selected );
3932 SALOME_ListIteratorOfListIO it(selected);
3933 for( ; it.More(); it.Next()) {
3934 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3935 if(anIObject->hasEntry())
3936 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3937 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3942 case SMESHOp::OpPropertiesLength:
3943 case SMESHOp::OpPropertiesArea:
3944 case SMESHOp::OpPropertiesVolume:
3945 case SMESHOp::OpMinimumDistance:
3946 case SMESHOp::OpBoundingBox:
3947 case SMESHOp::OpAngle:
3949 int page = SMESHGUI_MeasureDlg::MinDistance;
3950 if ( theCommandID == SMESHOp::OpBoundingBox )
3951 page = SMESHGUI_MeasureDlg::BoundingBox;
3952 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3953 page = SMESHGUI_MeasureDlg::Length;
3954 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3955 page = SMESHGUI_MeasureDlg::Area;
3956 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3957 page = SMESHGUI_MeasureDlg::Volume;
3958 else if ( theCommandID == SMESHOp::OpAngle )
3959 page = SMESHGUI_MeasureDlg::Angle;
3961 EmitSignalDeactivateDialog();
3962 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3966 case SMESHOp::OpSortChild:
3969 case SMESHOp::OpBreakLink:
3970 ::breakShaperLink();
3975 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3976 //updateObjBrowser();
3980 //=============================================================================
3984 //=============================================================================
3985 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3990 //=============================================================================
3994 //=============================================================================
3995 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4000 //=============================================================================
4004 //=============================================================================
4005 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4010 //=============================================================================
4011 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4012 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4014 //=============================================================================
4015 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4016 SUIT_ViewWindow* wnd )
4018 if(theIO->hasEntry()){
4019 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4020 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4024 //=======================================================================
4025 // function : createSMESHAction
4027 //=======================================================================
4028 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4029 const int key, const bool toggle, const QString& shortcutAction )
4032 QWidget* parent = application()->desktop();
4033 SUIT_ResourceMgr* resMgr = resourceMgr();
4035 if ( !icon_id.isEmpty() )
4036 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4038 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4039 if ( !pix.isNull() )
4040 icon = QIcon( pix );
4042 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4043 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4044 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4046 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4047 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4050 //=======================================================================
4051 // function : createPopupItem
4053 //=======================================================================
4054 void SMESHGUI::createPopupItem( const int id,
4055 const QString& clients,
4056 const QString& types,
4057 const QString& theRule,
4060 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4061 popupMgr()->insert( action( id ), pId, 0 );
4063 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4064 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4065 QString rule = "(%1) and (%2) and (%3)";
4066 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4067 if( clients.isEmpty() )
4068 rule = rule.arg( QString( "true" ) );
4070 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4071 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4074 bool cont = myRules.contains( id );
4076 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4078 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4079 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4082 //=======================================================================
4083 // function : initialize
4085 //=======================================================================
4086 void SMESHGUI::initialize( CAM_Application* app )
4088 SalomeApp_Module::initialize( app );
4090 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4092 /* Automatic Update flag */
4093 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4095 // ----- create actions --------------
4097 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4098 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4099 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4100 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4102 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4104 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4105 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4106 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4107 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4109 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4111 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4113 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4114 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4115 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4116 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4118 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4120 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4121 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4122 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4123 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4124 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4126 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4128 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4129 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4130 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4131 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4132 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4133 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4134 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4135 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4136 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4137 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4138 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4139 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4140 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4141 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4142 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4143 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4144 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4145 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4146 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4147 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4148 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4149 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4150 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4151 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4152 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4153 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4154 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4155 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4156 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4157 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4158 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4159 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4160 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4161 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4162 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4164 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4165 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4166 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4167 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4168 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4169 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4170 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4171 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4172 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4173 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4174 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4175 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4176 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4177 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4178 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4179 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4180 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4181 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4182 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4183 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4184 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4185 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4186 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4187 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4188 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4189 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4190 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4191 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4192 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4194 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4195 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4196 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4197 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4198 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4199 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4200 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4201 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4202 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4203 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4204 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4205 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4206 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4207 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4208 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4209 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4210 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4211 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4212 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4213 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4214 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4215 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4216 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4217 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4218 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4219 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4221 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4222 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4223 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4224 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4226 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4227 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4229 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4230 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4231 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4232 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4233 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4234 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4235 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4236 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4237 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4238 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4239 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4240 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4241 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4242 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4243 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4244 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4245 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4246 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4247 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4248 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4249 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4250 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4251 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4252 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4253 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4255 createSMESHAction( SMESHOp::OpReset, "RESET" );
4256 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4257 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4258 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4259 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4260 #ifndef DISABLE_PLOT2DVIEWER
4261 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4263 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4264 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4265 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4266 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4267 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4268 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4269 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4270 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4271 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4272 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4273 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4274 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4275 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4277 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4278 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4280 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4281 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4282 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4283 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4284 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4285 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4286 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4287 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4288 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4290 // Adaptation - begin
4291 #ifndef DISABLE_MG_ADAPT
4292 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4294 #ifndef DISABLE_HOMARD_ADAPT
4295 createSMESHAction( SMESHOp::OpHomardAdapt, "HOMARD_ADAPT", "ICON_HOMARD_ADAPT" );
4299 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4300 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4301 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4302 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4303 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4304 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4306 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4307 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4308 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4310 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4312 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4314 QList<int> aCtrlActions;
4315 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4316 << SMESHOp::OpNodeConnectivityNb // node controls
4317 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4318 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4319 << SMESHOp::OpDeflection2D
4320 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4321 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4322 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4323 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4324 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4325 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4326 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4327 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4328 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4329 aCtrlGroup->setExclusive( true );
4330 for( int i = 0; i < aCtrlActions.size(); i++ )
4331 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4333 // ----- create menu --------------
4334 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4335 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4336 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4337 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4338 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4339 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4340 #if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
4341 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4343 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4344 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4346 createMenu( separator(), fileId );
4348 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4349 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4350 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4351 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4352 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4353 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4354 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4355 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4356 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4357 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4358 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4359 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4360 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4362 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4363 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4364 createMenu( SMESHOp::OpImportMED, importId, -1 );
4365 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4367 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4369 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4370 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4371 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4372 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4373 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4375 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4377 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4378 createMenu( separator(), fileId, 10 );
4380 createMenu( SMESHOp::OpDelete, editId, -1 );
4382 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4384 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4385 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4386 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4387 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4388 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4389 createMenu( separator(), meshId, -1 );
4390 createMenu( SMESHOp::OpCompute, meshId, -1 );
4391 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4392 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4393 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4394 createMenu( separator(), meshId, -1 );
4395 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4396 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4397 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4398 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4399 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4400 createMenu( separator(), meshId, -1 );
4401 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4402 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4403 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4404 createMenu( separator(), meshId, -1 );
4405 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4406 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4407 createMenu( separator(), meshId, -1 );
4408 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4409 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4410 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4411 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4412 createMenu( separator(), meshId, -1 );
4414 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4415 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4416 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4417 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4418 createMenu( SMESHOp::OpLength, edgeId, -1 );
4419 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4420 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4421 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4422 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4423 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4424 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4425 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4426 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4427 createMenu( SMESHOp::OpArea, faceId, -1 );
4428 createMenu( SMESHOp::OpTaper, faceId, -1 );
4429 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4430 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4431 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4432 createMenu( SMESHOp::OpSkew, faceId, -1 );
4433 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4434 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4435 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4436 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4437 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4438 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4439 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4440 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4441 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4442 createMenu( separator(), ctrlId, -1 );
4443 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4444 createMenu( separator(), ctrlId, -1 );
4445 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4447 createMenu( SMESHOp::OpNode, addId, -1 );
4448 createMenu( SMESHOp::OpElem0D, addId, -1 );
4449 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4450 createMenu( SMESHOp::OpBall, addId, -1 );
4451 createMenu( SMESHOp::OpEdge, addId, -1 );
4452 createMenu( SMESHOp::OpTriangle, addId, -1 );
4453 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4454 createMenu( SMESHOp::OpPolygon, addId, -1 );
4455 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4456 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4457 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4458 createMenu( SMESHOp::OpPyramid, addId, -1 );
4459 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4460 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4461 createMenu( separator(), addId, -1 );
4462 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4463 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4464 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4465 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4466 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4467 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4468 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4469 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4470 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4471 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4472 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4473 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4475 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4476 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4477 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4478 createMenu( separator(), removeId, -1 );
4479 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4480 createMenu( separator(), removeId, -1 );
4481 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4483 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4484 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4486 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4487 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4488 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4489 createMenu( SMESHOp::OpRotation, transfId, -1 );
4490 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4491 createMenu( SMESHOp::OpScale, transfId, -1 );
4492 createMenu( SMESHOp::OpOffset, transfId, -1 );
4493 createMenu( SMESHOp::OpSewing, transfId, -1 );
4494 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4496 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4497 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4498 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4499 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4500 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4501 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4502 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4503 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4504 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4505 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4506 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4507 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4508 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4509 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4510 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4511 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4513 // Adaptation - begin
4514 #ifndef DISABLE_MG_ADAPT
4515 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4517 #ifndef DISABLE_HOMARD_ADAPT
4518 createMenu( SMESHOp::OpHomardAdapt, adaptId, -1 );
4522 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4523 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4524 createMenu( SMESHOp::OpAngle, measureId, -1 );
4525 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4526 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4527 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4528 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4530 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4531 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4532 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4533 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4535 // ----- create toolbars --------------
4536 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4537 createTool( SMESHOp::OpCreateMesh, meshTb );
4538 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4539 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4540 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4541 createTool( SMESHOp::OpCopyMesh, meshTb );
4542 createTool( separator(), meshTb );
4543 createTool( SMESHOp::OpCompute, meshTb );
4544 createTool( SMESHOp::OpPreCompute, meshTb );
4545 createTool( SMESHOp::OpEvaluate, meshTb );
4546 createTool( SMESHOp::OpMeshOrder, meshTb );
4548 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4549 createTool( SMESHOp::OpMeshInformation, infoTb );
4550 //createTool( SMESHOp::OpStdInfo, meshTb );
4551 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4552 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4554 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4555 createTool( SMESHOp::OpCreateGroup, groupTb );
4556 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4557 createTool( SMESHOp::OpConstructGroup, groupTb );
4558 createTool( SMESHOp::OpEditGroup, groupTb );
4560 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4561 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4562 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4563 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4565 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4566 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4567 createTool( SMESHOp::OpLength, ctrl1dTb );
4568 createTool( SMESHOp::OpConnection, ctrl1dTb );
4569 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4571 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4572 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4573 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4574 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4575 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4576 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4577 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4578 createTool( SMESHOp::OpArea, ctrl2dTb );
4579 createTool( SMESHOp::OpTaper, ctrl2dTb );
4580 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4581 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4582 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4583 createTool( SMESHOp::OpSkew, ctrl2dTb );
4584 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4585 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4586 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4588 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4589 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4590 createTool( SMESHOp::OpVolume, ctrl3dTb );
4591 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4592 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4593 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4594 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4596 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4597 createTool( SMESHOp::OpNode, addElemTb );
4598 createTool( SMESHOp::OpElem0D, addElemTb );
4599 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4600 createTool( SMESHOp::OpBall, addElemTb );
4601 createTool( SMESHOp::OpEdge, addElemTb );
4602 createTool( SMESHOp::OpTriangle, addElemTb );
4603 createTool( SMESHOp::OpQuadrangle, addElemTb );
4604 createTool( SMESHOp::OpPolygon, addElemTb );
4605 createTool( SMESHOp::OpTetrahedron, addElemTb );
4606 createTool( SMESHOp::OpHexahedron, addElemTb );
4607 createTool( SMESHOp::OpPentahedron, addElemTb );
4608 createTool( SMESHOp::OpPyramid, addElemTb );
4609 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4610 createTool( SMESHOp::OpPolyhedron, addElemTb );
4612 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4613 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4614 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4615 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4616 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4617 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4618 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4619 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4620 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4621 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4622 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4623 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4624 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4626 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4627 createTool( SMESHOp::OpRemoveNodes, remTb );
4628 createTool( SMESHOp::OpRemoveElements, remTb );
4629 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4630 createTool( SMESHOp::OpClearMesh, remTb );
4632 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4633 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4634 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4636 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4637 createTool( SMESHOp::OpMergeNodes, transformTb );
4638 createTool( SMESHOp::OpMergeElements, transformTb );
4639 createTool( SMESHOp::OpTranslation, transformTb );
4640 createTool( SMESHOp::OpRotation, transformTb );
4641 createTool( SMESHOp::OpSymmetry, transformTb );
4642 createTool( SMESHOp::OpScale, transformTb );
4643 createTool( SMESHOp::OpOffset, transformTb );
4644 createTool( SMESHOp::OpSewing, transformTb );
4645 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4647 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4648 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4649 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4650 createTool( SMESHOp::OpExtrusion, modifyTb );
4651 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4652 createTool( SMESHOp::OpRevolution, modifyTb );
4653 createTool( SMESHOp::OpOrientation, modifyTb );
4654 createTool( SMESHOp::OpReorientFaces, modifyTb );
4655 createTool( SMESHOp::OpMoveNode, modifyTb );
4656 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4657 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4658 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4659 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4660 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4661 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4662 createTool( SMESHOp::OpSmoothing, modifyTb );
4663 createTool( SMESHOp::OpPatternMapping, modifyTb );
4665 // Adaptation - begin
4666 #if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
4667 int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
4669 #ifndef DISABLE_MG_ADAPT
4670 createTool( SMESHOp::OpMGAdapt, adaptTb );
4672 #ifndef DISABLE_HOMARD_ADAPT
4673 createTool( SMESHOp::OpHomardAdapt, adaptTb );
4677 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4678 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4680 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4681 createTool( SMESHOp::OpUpdate, dispModeTb );
4683 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4684 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4688 OB = "'ObjectBrowser'",
4689 View = "'" + SVTK_Viewer::Type() + "'",
4691 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4692 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4693 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4694 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4695 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4696 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4697 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4698 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4699 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4700 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4701 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4702 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4704 mesh_part = mesh + " " + subMesh + " " + group,
4705 mesh_group = mesh + " " + group,
4706 mesh_submesh = mesh + " " + subMesh,
4707 hyp_alg = hypo + " " + algo;
4709 // popup for object browser
4711 isInvisible("not( isVisible )"),
4712 isEmpty("numberOfNodes = 0"),
4713 isNotEmpty("numberOfNodes <> 0"),
4715 // has nodes, edges, etc in VISIBLE! actor
4716 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4717 hasElems("(count( elemTypes ) > 0)"),
4718 hasDifferentElems("(count( elemTypes ) > 1)"),
4719 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4720 hasBalls("({'BallElem'} in elemTypes)"),
4721 hasElems0d("({'Elem0d'} in elemTypes)"),
4722 hasEdges("({'Edge'} in elemTypes)"),
4723 hasFaces("({'Face'} in elemTypes)"),
4724 hasVolumes("({'Volume'} in elemTypes)"),
4725 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4727 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4728 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4729 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4730 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4731 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4732 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4734 popupMgr()->insert( separator(), -1, 0 );
4735 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4736 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4737 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4738 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4739 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4740 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4741 popupMgr()->insert( separator(), -1, 0 );
4742 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4743 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4744 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4745 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4746 popupMgr()->insert( separator(), -1, 0 );
4747 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4748 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4749 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4750 popupMgr()->insert( separator(), -1, 0 );
4751 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4752 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4753 popupMgr()->insert( separator(), -1, 0 );
4754 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4755 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4757 // Adaptation - begin
4758 popupMgr()->insert( separator(), -1, 0 );
4759 #ifndef DISABLE_MG_ADAPT
4760 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4762 #ifndef DISABLE_HOMARD_ADAPT
4763 createPopupItem( SMESHOp::OpHomardAdapt, OB, mesh );
4765 popupMgr()->insert( separator(), -1, 0 );
4768 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4769 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4770 QString only_one_2D = only_one_non_empty + " && dim>1";
4772 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4773 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4774 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4775 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4776 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4778 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4780 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4781 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4783 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4784 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4785 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4786 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4788 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4790 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4791 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4792 popupMgr()->insert( separator(), -1, 0 );
4794 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4795 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4796 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4799 createPopupItem( SMESHOp::OpEditGroup, View, group );
4800 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4801 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4803 popupMgr()->insert( separator(), -1, 0 );
4804 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4805 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4806 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4807 popupMgr()->insert( separator(), -1, 0 );
4809 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4810 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4811 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4812 popupMgr()->insert( separator(), -1, 0 );
4814 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4815 QString aType = QString( "%1type in {%2}" ).arg( lc );
4816 aType = aType.arg( mesh_part );
4817 QString aMeshInVTK = aClient + "&&" + aType;
4819 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4820 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4821 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4823 //-------------------------------------------------
4825 //-------------------------------------------------
4826 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4828 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4829 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4830 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4832 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4833 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4834 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4836 popupMgr()->insert( separator(), -1, -1 );
4838 //-------------------------------------------------
4840 //-------------------------------------------------
4841 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4843 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4844 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4845 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4847 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4848 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4849 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4851 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4853 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4855 popupMgr()->insert( separator(), anId, -1 );
4857 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4858 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4859 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4861 //-------------------------------------------------
4863 //-------------------------------------------------
4864 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4866 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4868 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4869 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4870 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4872 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4873 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4874 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4876 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4877 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4878 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4880 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4881 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4882 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4884 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4885 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4886 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4888 popupMgr()->insert( separator(), anId, -1 );
4890 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4891 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4893 popupMgr()->insert( separator(), anId, -1 );
4895 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4896 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4899 //-------------------------------------------------
4900 // Representation of the 2D Quadratic elements
4901 //-------------------------------------------------
4902 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4903 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4904 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4905 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4907 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4908 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4909 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4911 //-------------------------------------------------
4912 // Orientation of faces
4913 //-------------------------------------------------
4914 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4915 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4916 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4918 //-------------------------------------------------
4920 //-------------------------------------------------
4921 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4922 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4924 //-------------------------------------------------
4926 //-------------------------------------------------
4927 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4928 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4930 //-------------------------------------------------
4932 //-------------------------------------------------
4934 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4935 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4936 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4937 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4939 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4941 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4942 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4944 popupMgr()->insert( separator(), anId, -1 );
4946 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4948 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4949 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4950 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4952 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4953 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4954 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4956 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4957 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4958 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4960 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4962 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4963 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4964 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4966 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4967 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4968 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4970 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4971 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4972 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4973 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4974 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4975 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4977 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4979 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4980 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4983 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4984 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4985 QtxPopupMgr::VisibleRule );
4986 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4988 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4989 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4992 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4993 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4994 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4996 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4997 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4998 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
5000 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
5001 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5002 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
5004 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
5005 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5006 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5008 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5009 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5010 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5012 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5013 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5014 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5016 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5017 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5018 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5020 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5021 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5022 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5024 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5025 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5026 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5028 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5029 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5030 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5032 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5033 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5034 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5036 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5037 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5038 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5040 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5042 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5043 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5044 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5046 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5047 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5048 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5050 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5051 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5052 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5054 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5055 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5056 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5058 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5059 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5060 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5062 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5063 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5064 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5066 popupMgr()->insert( separator(), anId, -1 );
5068 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5069 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5070 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5071 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5072 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5074 popupMgr()->insert( separator(), anId, -1 );
5076 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5078 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5079 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5081 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5082 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5083 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5085 #ifndef DISABLE_PLOT2DVIEWER
5086 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5087 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5090 //-------------------------------------------------
5092 //-------------------------------------------------
5093 popupMgr()->insert( separator(), -1, -1 );
5094 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5095 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5096 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5097 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5099 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5100 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5102 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5103 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5105 popupMgr()->insert( separator(), -1, -1 );
5107 //-------------------------------------------------
5109 //-------------------------------------------------
5110 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5111 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5113 popupMgr()->insert( separator(), -1, -1 );
5115 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5116 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5117 popupMgr()->insert( separator(), -1, -1 );
5119 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5120 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5122 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5123 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5125 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5126 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5129 //================================================================================
5131 * \brief Return true if SMESH or GEOM objects are selected.
5132 * Is called form LightApp_Module::activateModule() which clear selection if
5133 * not isSelectionCompatible()
5135 //================================================================================
5137 bool SMESHGUI::isSelectionCompatible()
5139 bool isCompatible = true;
5140 SALOME_ListIO selected;
5141 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5142 Sel->selectedObjects( selected );
5144 SALOME_ListIteratorOfListIO It( selected );
5145 for ( ; isCompatible && It.More(); It.Next())
5147 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5148 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5149 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5151 return isCompatible;
5155 bool SMESHGUI::reusableOperation( const int id )
5157 // compute, evaluate and precompute are not reusable operations
5158 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5163 QString wrap(const QString& text, const QString& tag)
5164 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5167 bool SMESHGUI::activateModule( SUIT_Study* study )
5169 bool res = SalomeApp_Module::activateModule( study );
5171 setMenuShown( true );
5172 setToolShown( true );
5174 // Fill in Help Panel
5175 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5176 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5178 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5181 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5182 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5183 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5184 lab = lab + tr("INFO_REFINE") + ":";
5185 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5186 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5187 lab = lab + wrap(items.join(""), "ul");
5190 app->infoPanel()->addLabel(lab, gb);
5192 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5193 items << wrap("UNV", "li")
5194 << wrap("MED", "li")
5195 << wrap("STL", "li")
5196 << wrap("CGNS", "li")
5197 << wrap("GMF", "li");
5198 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5201 app->infoPanel()->addLabel(lab, gb);
5203 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5204 lab = tr("INFO_DISPLAY") + "<br/>";
5205 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5206 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5207 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5208 << wrap("...", "li");
5209 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5211 lab = lab + tr("INFO_CLIPPING");
5213 app->infoPanel()->addLabel(lab, gb);
5216 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5217 PyGILState_STATE gstate = PyGILState_Ensure();
5218 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5219 if ( !pluginsmanager ) {
5223 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5228 PyGILState_Release(gstate);
5229 // end of SMESH plugins loading
5231 // Reset actions accelerator keys
5232 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5234 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5235 GetSMESHGen()->UpdateStudy();
5237 // get all view currently opened in the study and connect their signals to
5238 // the corresponding slots of the class.
5239 SUIT_Desktop* aDesk = study->application()->desktop();
5241 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5242 SUIT_ViewWindow* wnd;
5243 foreach ( wnd, wndList )
5247 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5248 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5254 Py_XDECREF(pluginsmanager);
5258 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5260 setMenuShown( false );
5261 setToolShown( false );
5263 EmitSignalCloseAllDialogs();
5265 // Unset actions accelerator keys
5266 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5268 return SalomeApp_Module::deactivateModule( study );
5271 void SMESHGUI::studyClosed( SUIT_Study* s )
5275 SMESH::RemoveVisuData();
5276 SalomeApp_Module::studyClosed( s );
5279 void SMESHGUI::OnGUIEvent()
5281 const QObject* obj = sender();
5282 if ( !obj || !obj->inherits( "QAction" ) )
5284 int id = actionId((QAction*)obj);
5289 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5291 if ( CORBA::is_nil( myComponentSMESH ) )
5293 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5294 return aGUI.myComponentSMESH;
5296 return myComponentSMESH;
5299 QString SMESHGUI::engineIOR() const
5301 CORBA::ORB_var anORB = getApp()->orb();
5302 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5303 return QString( anIOR.in() );
5306 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5308 SalomeApp_Module::contextMenuPopup( client, menu, title );
5310 selectionMgr()->selectedObjects( lst );
5311 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5312 Handle(SALOME_InteractiveObject) io = lst.First();
5313 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5314 _PTR(Study) study = appStudy->studyDS();
5315 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5317 QString aName = SMESH::fromUtf8( obj->GetName());
5318 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5319 aName.remove(( aName.length() - 1 ), 1 );
5325 LightApp_Selection* SMESHGUI::createSelection() const
5327 return new SMESHGUI_Selection();
5330 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5332 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5333 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5334 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5335 #ifndef DISABLE_PYCONSOLE
5336 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5340 void SMESHGUI::viewManagers( QStringList& list ) const
5342 list.append( SVTK_Viewer::Type() );
5345 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5347 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5348 SMESH::UpdateSelectionProp( this );
5350 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5351 for(int i = 0; i < aViews.count() ; i++){
5352 SUIT_ViewWindow *sf = aViews[i];
5355 EmitSignalActivatedViewManager();
5359 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5361 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5362 myClippingPlaneInfoMap.erase( theViewManager );
5365 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5367 theActor->AddObserver( SMESH::DeleteActorEvent,
5368 myEventCallbackCommand.GetPointer(),
5372 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5373 unsigned long theEvent,
5374 void* theClientData,
5375 void* /*theCallData*/ )
5377 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5378 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5379 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5380 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5381 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5382 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5383 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5384 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5385 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5386 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5387 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5388 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5389 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5390 if( anActor == *anIter3 ) {
5391 anActorList.erase( anIter3 );
5402 void SMESHGUI::createPreferences()
5404 // General tab ------------------------------------------------------------------------
5405 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5407 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5408 setPreferenceProperty( autoUpdate, "columns", 2 );
5409 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5410 setPreferenceProperty( lim, "min", 0 );
5411 setPreferenceProperty( lim, "max", 100000000 );
5412 setPreferenceProperty( lim, "step", 1000 );
5413 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5414 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5416 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5417 setPreferenceProperty( dispgroup, "columns", 2 );
5419 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5421 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5423 modes.append( tr("MEN_WIRE") );
5424 modes.append( tr("MEN_SHADE") );
5425 modes.append( tr("MEN_NODES") );
5426 modes.append( tr("MEN_SHRINK") );
5427 QList<QVariant> indices;
5428 indices.append( 0 );
5429 indices.append( 1 );
5430 indices.append( 2 );
5431 indices.append( 3 );
5432 setPreferenceProperty( dispmode, "strings", modes );
5433 setPreferenceProperty( dispmode, "indexes", indices );
5435 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5436 setPreferenceProperty( arcgroup, "columns", 2 );
5437 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5438 QStringList quadraticModes;
5439 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5440 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5442 indices.append( 0 );
5443 indices.append( 1 );
5444 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5445 setPreferenceProperty( quadraticmode, "indexes", indices );
5447 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5448 "SMESH", "max_angle" );
5449 setPreferenceProperty( maxAngle, "min", 1 );
5450 setPreferenceProperty( maxAngle, "max", 90 );
5452 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5453 setPreferenceProperty( qaGroup, "columns", 2 );
5454 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5455 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5456 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5457 setPreferenceProperty( prec, "min", 0 );
5458 setPreferenceProperty( prec, "max", 100 );
5459 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5460 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5461 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5462 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5463 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5466 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5467 setPreferenceProperty( cinc, "min", 0 );
5468 setPreferenceProperty( cinc, "max", 5 );
5471 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5472 setPreferenceProperty( exportgroup, "columns", 2 );
5473 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5474 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5475 addPreference( tr( "PREF_MED_SAVE_NUMS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "med_save_numbers" );
5476 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5477 setPreferenceProperty( zTol, "precision", 10 );
5478 setPreferenceProperty( zTol, "min", 0.0000000001 );
5479 setPreferenceProperty( zTol, "max", 1000000.0 );
5480 setPreferenceProperty( zTol, "step", 1. );
5481 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5483 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5484 setPreferenceProperty( computeGroup, "columns", 2 );
5485 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5487 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5488 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5489 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5491 indices.append( 0 );
5492 indices.append( 1 );
5493 indices.append( 2 );
5494 setPreferenceProperty( notifyMode, "strings", modes );
5495 setPreferenceProperty( notifyMode, "indexes", indices );
5497 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5498 setPreferenceProperty( infoGroup, "columns", 2 );
5499 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5501 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5502 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5504 indices.append( 0 );
5505 indices.append( 1 );
5506 setPreferenceProperty( elemInfo, "strings", modes );
5507 setPreferenceProperty( elemInfo, "indexes", indices );
5508 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5509 setPreferenceProperty( nodesLim, "min", 0 );
5510 setPreferenceProperty( nodesLim, "max", 10000000 );
5511 setPreferenceProperty( nodesLim, "step", 10000 );
5512 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5513 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5514 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5515 setPreferenceProperty( ctrlLim, "min", 0 );
5516 setPreferenceProperty( ctrlLim, "max", 10000000 );
5517 setPreferenceProperty( ctrlLim, "step", 1000 );
5518 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5519 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5520 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5521 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5522 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5524 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5525 setPreferenceProperty( segGroup, "columns", 2 );
5526 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5527 "SMESH", "segmentation" );
5528 setPreferenceProperty( segLen, "min", 1 );
5529 setPreferenceProperty( segLen, "max", 10000000 );
5530 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5531 "SMESH", "nb_segments_per_edge" );
5532 setPreferenceProperty( nbSeg, "min", 1 );
5533 setPreferenceProperty( nbSeg, "max", 10000000 );
5534 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5536 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5537 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5538 "SMESH", "forget_mesh_on_hyp_modif" );
5541 // Quantities with individual precision settings
5542 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5543 setPreferenceProperty( precGroup, "columns", 2 );
5545 const int nbQuantities = 6;
5546 int precs[nbQuantities], ii = 0;
5547 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5548 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5549 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5550 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5551 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5552 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5553 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5554 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5555 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5556 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5557 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5558 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5560 // Set property for precision value for spinboxes
5561 for ( ii = 0; ii < nbQuantities; ii++ ){
5562 setPreferenceProperty( precs[ii], "min", -14 );
5563 setPreferenceProperty( precs[ii], "max", 14 );
5564 setPreferenceProperty( precs[ii], "precision", 2 );
5567 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5568 setPreferenceProperty( previewGroup, "columns", 2 );
5569 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5570 setPreferenceProperty( chunkSize, "min", 1 );
5571 setPreferenceProperty( chunkSize, "max", 1000 );
5572 setPreferenceProperty( chunkSize, "step", 50 );
5574 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5575 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5577 // Mesh tab ------------------------------------------------------------------------
5578 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5579 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5580 setPreferenceProperty( nodeGroup, "columns", 3 );
5582 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5584 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5586 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5587 QList<QVariant> aMarkerTypeIndicesList;
5588 QList<QVariant> aMarkerTypeIconsList;
5589 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5590 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5591 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5592 aMarkerTypeIndicesList << i;
5593 aMarkerTypeIconsList << pixmap;
5595 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5596 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5598 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5600 QList<QVariant> aMarkerScaleIndicesList;
5601 QStringList aMarkerScaleValuesList;
5602 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5603 aMarkerScaleIndicesList << i;
5604 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5605 aMarkerScaleValuesList << QString::number( i );
5607 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5608 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5610 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5611 //setPreferenceProperty( elemGroup, "columns", 2 );
5613 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5614 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5615 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5616 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5617 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5618 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5619 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5620 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5621 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5624 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5625 setPreferenceProperty( grpGroup, "columns", 2 );
5627 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5628 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5630 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5631 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5632 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5633 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5634 int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5635 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5636 int ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5637 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5638 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5639 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5640 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5641 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5642 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5643 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5645 setPreferenceProperty( size0d, "min", 1 );
5646 setPreferenceProperty( size0d, "max", 10 );
5648 // setPreferenceProperty( ballSize, "min", 1 );
5649 // setPreferenceProperty( ballSize, "max", 10 );
5651 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5652 setPreferenceProperty( ballDiameter, "max", 1e9 );
5653 setPreferenceProperty( ballDiameter, "step", 0.1 );
5655 setPreferenceProperty( ballScale, "min", 1e-2 );
5656 setPreferenceProperty( ballScale, "max", 1e7 );
5657 setPreferenceProperty( ballScale, "step", 0.5 );
5659 setPreferenceProperty( elemW, "min", 1 );
5660 setPreferenceProperty( elemW, "max", 5 );
5662 setPreferenceProperty( outW, "min", 1 );
5663 setPreferenceProperty( outW, "max", 5 );
5665 setPreferenceProperty( shrink, "min", 0 );
5666 setPreferenceProperty( shrink, "max", 100 );
5668 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5669 setPreferenceProperty( numGroup, "columns", 2 );
5671 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5672 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5674 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5675 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5677 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5678 setPreferenceProperty( orientGroup, "columns", 1 );
5680 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5681 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5683 setPreferenceProperty( orientScale, "min", 0.05 );
5684 setPreferenceProperty( orientScale, "max", 0.5 );
5685 setPreferenceProperty( orientScale, "step", 0.05 );
5687 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5689 // Selection tab ------------------------------------------------------------------------
5690 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5692 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5693 setPreferenceProperty( selGroup, "columns", 2 );
5695 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5696 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5698 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5699 setPreferenceProperty( preGroup, "columns", 2 );
5701 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5703 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5704 setPreferenceProperty( precSelGroup, "columns", 2 );
5706 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5707 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5708 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5710 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5711 setPreferenceProperty( sinc, "min", 0 );
5712 setPreferenceProperty( sinc, "max", 5 );
5714 // Scalar Bar tab ------------------------------------------------------------------------
5715 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5716 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5717 setPreferenceProperty( fontGr, "columns", 2 );
5719 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5720 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5722 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5723 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5725 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5726 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5728 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5729 setPreferenceProperty( numcol, "min", 2 );
5730 setPreferenceProperty( numcol, "max", 256 );
5732 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5733 setPreferenceProperty( numlab, "min", 2 );
5734 setPreferenceProperty( numlab, "max", 65 );
5736 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5737 setPreferenceProperty( orientGr, "columns", 2 );
5738 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5739 QStringList orients;
5740 orients.append( tr( "SMESH_VERTICAL" ) );
5741 orients.append( tr( "SMESH_HORIZONTAL" ) );
5742 indices.clear(); indices.append( 0 ); indices.append( 1 );
5743 setPreferenceProperty( orient, "strings", orients );
5744 setPreferenceProperty( orient, "indexes", indices );
5746 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5747 setPreferenceProperty( posVSizeGr, "columns", 2 );
5748 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5749 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5750 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5751 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5752 setPreferenceProperty( xv, "step", 0.1 );
5753 setPreferenceProperty( xv, "min", 0.0 );
5754 setPreferenceProperty( xv, "max", 1.0 );
5755 setPreferenceProperty( yv, "step", 0.1 );
5756 setPreferenceProperty( yv, "min", 0.0 );
5757 setPreferenceProperty( yv, "max", 1.0 );
5758 setPreferenceProperty( wv, "step", 0.1 );
5759 setPreferenceProperty( wv, "min", 0.0 );
5760 setPreferenceProperty( wv, "max", 1.0 );
5761 setPreferenceProperty( hv, "min", 0.0 );
5762 setPreferenceProperty( hv, "max", 1.0 );
5763 setPreferenceProperty( hv, "step", 0.1 );
5765 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5766 setPreferenceProperty( posHSizeGr, "columns", 2 );
5767 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5768 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5769 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5770 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5771 setPreferenceProperty( xv, "min", 0.0 );
5772 setPreferenceProperty( xv, "max", 1.0 );
5773 setPreferenceProperty( xv, "step", 0.1 );
5774 setPreferenceProperty( xh, "min", 0.0 );
5775 setPreferenceProperty( xh, "max", 1.0 );
5776 setPreferenceProperty( xh, "step", 0.1 );
5777 setPreferenceProperty( yh, "min", 0.0 );
5778 setPreferenceProperty( yh, "max", 1.0 );
5779 setPreferenceProperty( yh, "step", 0.1 );
5780 setPreferenceProperty( wh, "min", 0.0 );
5781 setPreferenceProperty( wh, "max", 1.0 );
5782 setPreferenceProperty( wh, "step", 0.1 );
5783 setPreferenceProperty( hh, "min", 0.0 );
5784 setPreferenceProperty( hh, "max", 1.0 );
5785 setPreferenceProperty( hh, "step", 0.1 );
5787 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5788 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5789 setPreferenceProperty( distributionGr, "columns", 3 );
5791 types.append( tr( "SMESH_MONOCOLOR" ) );
5792 types.append( tr( "SMESH_MULTICOLOR" ) );
5793 indices.clear(); indices.append( 0 ); indices.append( 1 );
5794 setPreferenceProperty( coloringType, "strings", types );
5795 setPreferenceProperty( coloringType, "indexes", indices );
5796 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5798 // Adaptation - begin
5799 #ifndef DISABLE_MG_ADAPT
5800 // Adaptation tab ------------------------------------------------------------------------
5801 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5804 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5805 setPreferenceProperty( bloc, "columns", 1 );
5806 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5807 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5808 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5809 QStringList aListOfSizeMap;
5810 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5811 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5812 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5813 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5814 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5815 QStringList aListOfTimeStep;
5816 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5817 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5818 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5819 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5824 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5826 if ( sect=="SMESH" ) {
5827 double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5828 double aTol = 1.00000009999999;
5829 std::string aWarning;
5830 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5832 if ( name == "selection_object_color" ||
5833 name == "selection_element_color" ||
5834 name == "highlight_color" ||
5835 name == "selection_precision_node" ||
5836 name == "selection_precision_element" ||
5837 name == "selection_precision_object" ||
5838 name == "selection_increment")
5840 SMESH::UpdateSelectionProp( this );
5842 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5844 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5845 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5846 if ( sbX1+sbW > aTol ) {
5847 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5850 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5851 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5854 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5856 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5857 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5858 if ( sbY1 + sbH > aTol ) {
5859 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5860 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5861 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5864 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5866 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5867 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5868 if ( sbX1 + sbW > aTol ) {
5869 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5872 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5873 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5876 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5878 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5879 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5880 if ( sbY1 + sbH > aTol ) {
5881 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5884 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5885 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5888 else if ( name == "segmentation" )
5890 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5891 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5893 else if ( name == "nb_segments_per_edge" )
5895 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5896 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5898 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5900 QString val = aResourceMgr->stringValue( "SMESH", name );
5901 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5903 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5905 SMESH::UpdateFontProp( this );
5907 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5909 SMESH::UpdateFontProp( this );
5912 if ( aWarning.size() != 0 ) {
5913 aWarning += "The default values are applied instead.";
5914 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5915 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5916 QObject::tr(aWarning.c_str()));
5921 //================================================================================
5923 * \brief Update something in accordance with update flags
5924 * \param theFlags - update flags
5926 * Update viewer or/and object browser etc. in accordance with update flags ( see
5927 * LightApp_UpdateFlags enumeration ).
5929 //================================================================================
5930 void SMESHGUI::update( const int flags )
5932 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5933 SMESH::UpdateView();
5935 SalomeApp_Module::update( flags );
5938 //================================================================================
5940 * \brief Set default selection mode
5942 * SLOT called when operation committed. Sets default selection mode
5944 //================================================================================
5945 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5947 SVTK_ViewWindow* vtkWnd =
5948 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5950 vtkWnd->SetSelectionMode( ActorSelection );
5953 //================================================================================
5955 * \brief Set default selection mode
5957 * SLOT called when operation aborted. Sets default selection mode
5959 //================================================================================
5960 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5962 SVTK_ViewWindow* vtkWnd =
5963 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5965 vtkWnd->SetSelectionMode( ActorSelection );
5968 //================================================================================
5970 * \brief Creates operation with given identifier
5971 * \param id - identifier of operation to be started
5972 * \return Pointer on created operation or NULL if operation is not created
5974 * Virtual method redefined from the base class creates operation with given id.
5975 * It is called called automatically from startOperation method of base class.
5977 //================================================================================
5978 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5980 LightApp_Operation* op = 0;
5981 // to do : create operation here
5984 case SMESHOp::OpSplitBiQuadratic:
5985 op = new SMESHGUI_SplitBiQuadOp();
5987 case SMESHOp::OpConvertMeshToQuadratic:
5988 op = new SMESHGUI_ConvToQuadOp();
5990 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5991 op = new SMESHGUI_Make2DFrom3DOp();
5993 case SMESHOp::OpReorientFaces:
5994 op = new SMESHGUI_ReorientFacesOp();
5996 case SMESHOp::OpCreateMesh:
5997 op = new SMESHGUI_MeshOp( true, true );
5999 case SMESHOp::OpCreateSubMesh:
6000 op = new SMESHGUI_MeshOp( true, false );
6002 case SMESHOp::OpEditMeshOrSubMesh:
6003 case SMESHOp::OpEditMesh:
6004 case SMESHOp::OpEditSubMesh:
6005 op = new SMESHGUI_MeshOp( false );
6007 case SMESHOp::OpCompute:
6008 case SMESHOp::OpComputeSubMesh:
6009 op = new SMESHGUI_ComputeOp();
6011 case SMESHOp::OpShowErrors:
6012 op = new SMESHGUI_ShowErrorsOp();
6014 case SMESHOp::OpPreCompute:
6015 op = new SMESHGUI_PrecomputeOp();
6017 case SMESHOp::OpEvaluate:
6018 op = new SMESHGUI_EvaluateOp();
6020 case SMESHOp::OpMeshOrder:
6021 op = new SMESHGUI_MeshOrderOp();
6023 case SMESHOp::OpCreateGeometryGroup:
6024 op = new SMESHGUI_GroupOnShapeOp();
6026 case SMESHOp::OpFindElementByPoint:
6027 op = new SMESHGUI_FindElemByPointOp();
6029 case SMESHOp::OpMoveNode: // Make mesh pass through point
6030 op = new SMESHGUI_MakeNodeAtPointOp();
6032 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6033 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6040 op = SalomeApp_Module::createOperation( id );
6044 //================================================================================
6046 * \brief Stops current operations and starts a given one
6047 * \param id - The id of the operation to start
6049 //================================================================================
6051 void SMESHGUI::switchToOperation(int id)
6053 activeStudy()->abortAllOperations();
6054 startOperation( id );
6057 LightApp_Displayer* SMESHGUI::displayer()
6060 myDisplayer = new SMESHGUI_Displayer( getApp() );
6064 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6067 int aTolerance = 64;
6068 int anIterations = 0;
6074 if( anIterations % aPeriod == 0 )
6077 if( aTolerance < 1 )
6081 aHue = (int)( 360.0 * rand() / RAND_MAX );
6084 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6085 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6086 for( ; it != itEnd; ++it )
6088 SALOMEDS::Color anAutoColor = *it;
6089 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6092 aQColor.getHsv( &h, &s, &v );
6093 if( abs( h - aHue ) < aTolerance )
6105 aColor.setHsv( aHue, 255, 255 );
6107 SALOMEDS::Color aSColor;
6108 aSColor.R = aColor.redF();
6109 aSColor.G = aColor.greenF();
6110 aSColor.B = aColor.blueF();
6115 const char* gSeparator = "_"; // character used to separate parameter names
6116 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6117 const char* gPathSep = "|"; // character used to separate paths
6120 * \brief Store visual parameters
6122 * This method is called just before the study document is saved.
6123 * Store visual parameters in AttributeParameter attribute(s)
6125 void SMESHGUI::storeVisualParameters (int savePoint)
6128 Kernel_Utils::Localizer loc;
6130 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6131 if (!appStudy || !appStudy->studyDS())
6133 _PTR(Study) studyDS = appStudy->studyDS();
6135 // componentName is used for encoding of entries when storing them in IParameters
6136 std::string componentName = myComponentSMESH->ComponentDataType();
6137 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6138 //if (!aSComponent) return;
6141 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6142 componentName.c_str(),
6144 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6146 // store custom markers
6147 if( !myMarkerMap.empty() )
6149 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6150 for( ; anIter != myMarkerMap.end(); anIter++ )
6152 int anId = anIter->first;
6153 VTK::MarkerData aMarkerData = anIter->second;
6154 std::string aMarkerFileName = aMarkerData.first;
6155 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6156 if( aMarkerTexture.size() < 3 )
6157 continue; // should contain at least width, height and the first value
6159 QString aPropertyName( "texture" );
6160 aPropertyName += gSeparator;
6161 aPropertyName += QString::number( anId );
6163 QString aPropertyValue = aMarkerFileName.c_str();
6164 aPropertyValue += gPathSep;
6166 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6167 ushort aWidth = *aTextureIter++;
6168 ushort aHeight = *aTextureIter++;
6169 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6170 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6171 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6172 aPropertyValue += QString::number( *aTextureIter );
6174 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6178 // viewers counters are used for storing view_numbers in IParameters
6181 // main cycle to store parameters of displayed objects
6182 QList<SUIT_ViewManager*> lst;
6183 QList<SUIT_ViewManager*>::Iterator it;
6184 getApp()->viewManagers(lst);
6185 for (it = lst.begin(); it != lst.end(); it++)
6187 SUIT_ViewManager* vman = *it;
6188 QString vType = vman->getType();
6190 // saving VTK actors properties
6191 if (vType == SVTK_Viewer::Type())
6193 // store the clipping planes attached to the view manager
6194 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6195 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6196 if( anIter != myClippingPlaneInfoMap.end() )
6197 aClippingPlaneInfoList = anIter->second;
6199 if( !aClippingPlaneInfoList.empty() ) {
6200 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6201 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6203 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6204 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6206 QString aPropertyName( "ClippingPlane" );
6207 aPropertyName += gSeparator;
6208 aPropertyName += QString::number( vtkViewers );
6209 aPropertyName += gSeparator;
6210 aPropertyName += QString::number( anId );
6212 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6213 aPropertyValue += gDigitsSep;
6214 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6215 aPropertyValue += gDigitsSep;
6216 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6217 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6218 aPropertyValue += gDigitsSep;
6219 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6220 aPropertyValue += gDigitsSep;
6221 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6222 aPropertyValue += gDigitsSep;
6223 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6224 aPropertyValue += gDigitsSep;
6225 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6226 aPropertyValue += gDigitsSep;
6227 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6228 aPropertyValue += gDigitsSep;
6229 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6231 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6232 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6233 aPropertyValue += gDigitsSep;
6234 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6235 aPropertyValue += gDigitsSep;
6236 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6237 aPropertyValue += gDigitsSep;
6238 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6241 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6245 QVector<SUIT_ViewWindow*> views = vman->getViews();
6246 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6248 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6250 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6251 vtkActorCollection* allActors = aCopy.GetActors();
6252 allActors->InitTraversal();
6253 while (vtkActor* actor = allActors->GetNextActor())
6255 if (actor->GetVisibility()) // store only visible actors
6257 SMESH_Actor* aSmeshActor = 0;
6258 if (actor->IsA("SMESH_Actor"))
6259 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6260 if (aSmeshActor && aSmeshActor->hasIO())
6262 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6265 // entry is "encoded" = it does NOT contain component address,
6266 // since it is a subject to change on next component loading
6267 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6269 std::string param, vtkParam = vType.toLatin1().data();
6270 vtkParam += gSeparator;
6271 vtkParam += QString::number(vtkViewers).toLatin1().data();
6272 vtkParam += gSeparator;
6275 param = vtkParam + "Visibility";
6276 ip->setParameter(entry, param, "On");
6279 param = vtkParam + "Representation";
6280 ip->setParameter(entry, param, QString::number
6281 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6284 param = vtkParam + "IsShrunk";
6285 ip->setParameter(entry, param, QString::number
6286 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6288 // Displayed entities
6289 unsigned int aMode = aSmeshActor->GetEntityMode();
6290 bool isE = aMode & SMESH_Actor::eEdges;
6291 bool isF = aMode & SMESH_Actor::eFaces;
6292 bool isV = aMode & SMESH_Actor::eVolumes;
6293 bool is0d = aMode & SMESH_Actor::e0DElements;
6294 bool isB = aMode & SMESH_Actor::eBallElem;
6296 QString modeStr ("e");
6297 modeStr += gDigitsSep; modeStr += QString::number(isE);
6298 modeStr += gDigitsSep; modeStr += "f";
6299 modeStr += gDigitsSep; modeStr += QString::number(isF);
6300 modeStr += gDigitsSep; modeStr += "v";
6301 modeStr += gDigitsSep; modeStr += QString::number(isV);
6302 modeStr += gDigitsSep; modeStr += "0d";
6303 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6304 modeStr += gDigitsSep; modeStr += "b";
6305 modeStr += gDigitsSep; modeStr += QString::number(isB);
6307 param = vtkParam + "Entities";
6308 ip->setParameter(entry, param, modeStr.toLatin1().data());
6314 aSmeshActor->GetSufaceColor(r, g, b, delta);
6315 QStringList colorStr;
6316 colorStr << "surface";
6317 colorStr << QString::number(r);
6318 colorStr << QString::number(g);
6319 colorStr << QString::number(b);
6321 colorStr << "backsurface";
6322 colorStr << QString::number(delta);
6324 aSmeshActor->GetVolumeColor(r, g, b, delta);
6325 colorStr << "volume";
6326 colorStr << QString::number(r);
6327 colorStr << QString::number(g);
6328 colorStr << QString::number(b);
6329 colorStr << QString::number(delta);
6331 aSmeshActor->GetEdgeColor(r, g, b);
6333 colorStr << QString::number(r);
6334 colorStr << QString::number(g);
6335 colorStr << QString::number(b);
6337 aSmeshActor->GetNodeColor(r, g, b);
6339 colorStr << QString::number(r);
6340 colorStr << QString::number(g);
6341 colorStr << QString::number(b);
6343 aSmeshActor->GetOutlineColor(r, g, b);
6344 colorStr << "outline";
6345 colorStr << QString::number(r);
6346 colorStr << QString::number(g);
6347 colorStr << QString::number(b);
6349 aSmeshActor->Get0DColor(r, g, b);
6350 colorStr << "elem0d";
6351 colorStr << QString::number(r);
6352 colorStr << QString::number(g);
6353 colorStr << QString::number(b);
6355 aSmeshActor->GetBallColor(r, g, b);
6357 colorStr << QString::number(r);
6358 colorStr << QString::number(g);
6359 colorStr << QString::number(b);
6361 aSmeshActor->GetFacesOrientationColor(r, g, b);
6362 colorStr << "orientation";
6363 colorStr << QString::number(r);
6364 colorStr << QString::number(g);
6365 colorStr << QString::number(b);
6367 param = vtkParam + "Colors";
6368 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6371 QStringList sizeStr;
6373 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6374 sizeStr << "outline";
6375 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6376 sizeStr << "elem0d";
6377 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6379 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6380 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6381 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6382 sizeStr << "shrink";
6383 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6384 sizeStr << "orientation";
6385 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6386 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6388 param = vtkParam + "Sizes";
6389 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6394 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6395 if( aMarkerType == VTK::MT_USER ) {
6396 markerStr += "custom";
6397 markerStr += gDigitsSep;
6398 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6402 markerStr += gDigitsSep;
6403 markerStr += QString::number( (int)aMarkerType );
6404 markerStr += gDigitsSep;
6405 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6408 param = vtkParam + "PointMarker";
6409 ip->setParameter(entry, param, markerStr.toLatin1().data());
6412 param = vtkParam + "Opacity";
6413 ip->setParameter(entry, param,
6414 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6417 param = vtkParam + "ClippingPlane";
6419 if( !aClippingPlaneInfoList.empty() ) {
6420 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6421 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6423 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6424 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6425 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6426 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6427 if( aSmeshActor == *anIter2 ) {
6428 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6429 QString::number( anId ).toLatin1().constData() );
6436 ip->setParameter( entry, param, "Off" );
6437 } // if (io->hasEntry())
6438 } // SMESH_Actor && hasIO
6440 } // while.. actors traversal
6444 } // if (SVTK view model)
6445 } // for (viewManagers)
6448 // data structures for clipping planes processing
6452 bool isOpenGLClipping;
6453 vtkIdType RelativeOrientation;
6456 int AbsoluteOrientation;
6457 double X, Y, Z, Dx, Dy, Dz;
6459 typedef std::list<TPlaneData> TPlaneDataList;
6460 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6462 typedef std::list<vtkActor*> TActorList;
6465 TActorList ActorList;
6466 SUIT_ViewManager* ViewManager;
6468 typedef std::list<TPlaneInfo> TPlaneInfoList;
6469 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6472 * \brief Restore visual parameters
6474 * This method is called after the study document is opened.
6475 * Restore visual parameters from AttributeParameter attribute(s)
6477 void SMESHGUI::restoreVisualParameters (int savePoint)
6480 Kernel_Utils::Localizer loc;
6482 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6483 if (!appStudy || !appStudy->studyDS())
6485 _PTR(Study) studyDS = appStudy->studyDS();
6487 // componentName is used for encoding of entries when storing them in IParameters
6488 std::string componentName = myComponentSMESH->ComponentDataType();
6491 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6492 componentName.c_str(),
6494 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6496 // restore custom markers and map of clipping planes
6497 TPlaneDataMap aPlaneDataMap;
6499 std::vector<std::string> properties = ip->getProperties();
6500 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6502 std::string property = *propIt;
6503 QString aPropertyName( property.c_str() );
6504 QString aPropertyValue( ip->getProperty( property ).c_str() );
6506 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6507 if( aPropertyNameList.isEmpty() )
6510 QString aPropertyType = aPropertyNameList[0];
6511 if( aPropertyType == "texture" )
6513 if( aPropertyNameList.size() != 2 )
6517 int anId = aPropertyNameList[1].toInt( &ok );
6518 if( !ok || anId < 1 )
6521 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6522 if( aPropertyValueList.size() != 2 )
6525 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6526 QString aMarkerTextureString = aPropertyValueList[1];
6527 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6528 if( aMarkerTextureStringList.size() != 3 )
6532 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6537 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6541 VTK::MarkerTexture aMarkerTexture;
6542 aMarkerTexture.push_back( aWidth );
6543 aMarkerTexture.push_back( aHeight );
6545 QString aMarkerTextureData = aMarkerTextureStringList[2];
6546 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6548 QChar aChar = aMarkerTextureData.at( i );
6549 if( aChar.isDigit() )
6550 aMarkerTexture.push_back( aChar.digitValue() );
6553 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6555 else if( aPropertyType == "ClippingPlane" )
6557 if( aPropertyNameList.size() != 3 )
6561 int aViewId = aPropertyNameList[1].toInt( &ok );
6562 if( !ok || aViewId < 0 )
6566 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6567 if( !ok || aClippingPlaneId < 0 )
6570 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6571 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6574 TPlaneData aPlaneData;
6575 aPlaneData.AbsoluteOrientation = false;
6576 aPlaneData.RelativeOrientation = 0;
6577 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6578 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6579 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6581 aPlaneData.Id = aClippingPlaneId;
6584 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6589 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6593 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6596 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6601 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6606 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6611 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6616 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6621 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6626 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6630 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6632 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6637 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6642 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6647 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6652 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6653 aPlaneDataList.push_back( aPlaneData );
6657 TPlaneInfoMap aPlaneInfoMap;
6659 std::vector<std::string> entries = ip->getEntries();
6661 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6663 // entry is a normal entry - it should be "decoded" (setting base address of component)
6664 QString entry (ip->decodeEntry(*entIt).c_str());
6666 // Check that the entry corresponds to a real object in the Study
6667 // as the object may be deleted or modified after the visual state is saved.
6668 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6669 if (!so) continue; //Skip the not existent entry
6671 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6672 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6674 std::vector<std::string>::iterator namesIt = paramNames.begin();
6675 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6677 // actors are stored in a map after displaying of them for
6678 // quicker access in the future: map < viewID to actor >
6679 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6681 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6683 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6684 // '_' is used as separator and should not be used in viewer type or parameter names.
6685 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6686 if (lst.size() != 3)
6689 QString viewerTypStr = lst[0];
6690 QString viewIndexStr = lst[1];
6691 QString paramNameStr = lst[2];
6694 int viewIndex = viewIndexStr.toUInt(&ok);
6695 if (!ok) // bad conversion of view index to integer
6699 if (viewerTypStr == SVTK_Viewer::Type())
6701 SMESH_Actor* aSmeshActor = 0;
6702 if (vtkActors.IsBound(viewIndex))
6703 aSmeshActor = vtkActors.Find(viewIndex);
6705 QList<SUIT_ViewManager*> lst;
6706 getApp()->viewManagers(viewerTypStr, lst);
6708 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6709 SUIT_ViewManager* vman = NULL;
6710 if (viewIndex >= 0 && viewIndex < lst.count())
6711 vman = lst.at(viewIndex);
6713 if (paramNameStr == "Visibility")
6715 if (!aSmeshActor && displayer() && vman)
6717 SUIT_ViewModel* vmodel = vman->getViewModel();
6718 // SVTK view model can be casted to SALOME_View
6719 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6721 // store displayed actor in a temporary map for quicker
6722 // access later when restoring other parameters
6723 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6724 vtkRenderer* Renderer = vtkView->getRenderer();
6725 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6726 vtkActorCollection* theActors = aCopy.GetActors();
6727 theActors->InitTraversal();
6728 bool isFound = false;
6729 vtkActor *ac = theActors->GetNextActor();
6730 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6731 if (ac->IsA("SMESH_Actor")) {
6732 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6733 if (aGeomAc->hasIO()) {
6734 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6735 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6737 vtkActors.Bind(viewIndex, aGeomAc);
6743 } // if (paramNameStr == "Visibility")
6746 // the rest properties "work" with SMESH_Actor
6749 QString val ((*valuesIt).c_str());
6752 if (paramNameStr == "Representation") {
6753 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6756 else if (paramNameStr == "IsShrunk") {
6758 if (!aSmeshActor->IsShrunk())
6759 aSmeshActor->SetShrink();
6762 if (aSmeshActor->IsShrunk())
6763 aSmeshActor->UnShrink();
6766 // Displayed entities
6767 else if (paramNameStr == "Entities") {
6768 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6769 int aEntityMode = SMESH_Actor::eAllEntity;
6770 for ( int i = 0; i < mode.count(); i+=2 ) {
6771 if ( i < mode.count()-1 ) {
6772 QString type = mode[i];
6773 bool val = mode[i+1].toInt();
6774 if ( type == "e" && !val )
6775 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6776 else if ( type == "f" && !val )
6777 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6778 else if ( type == "v" && !val )
6779 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6780 else if ( type == "0d" && !val )
6781 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6782 else if ( type == "b" && !val )
6783 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6786 aSmeshActor->SetEntityMode( aEntityMode );
6789 else if (paramNameStr == "Colors") {
6790 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6797 QColor outlineColor;
6798 QColor orientationColor;
6804 // below lines are required to get default values for delta coefficients
6805 // of backface color for faces and color of reversed volumes
6806 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6807 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6808 for ( int i = 0; i < colors.count(); i++ ) {
6809 QString type = colors[i];
6810 if ( type == "surface" ) {
6811 // face color is set by 3 values r:g:b, where
6812 // - r,g,b - is rgb color components
6813 if ( i+1 >= colors.count() ) break; // format error
6814 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6815 if ( i+2 >= colors.count() ) break; // format error
6816 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6817 if ( i+3 >= colors.count() ) break; // format error
6818 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6819 faceColor.setRgbF( r, g, b );
6822 else if ( type == "backsurface" ) {
6823 // backface color can be defined in several ways
6824 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6825 // - in latest versions, it is set as delta coefficient
6826 bool rgbOk = false, deltaOk;
6827 if ( i+1 >= colors.count() ) break; // format error
6828 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6829 int delta = colors[i+1].toInt( &deltaOk );
6831 if ( i+1 < colors.count() ) // index is shifted to 1
6832 g = colors[i+1].toDouble( &rgbOk );
6833 if ( rgbOk ) i++; // shift index
6834 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6835 b = colors[i+1].toDouble( &rgbOk );
6837 // - as currently there's no way to set directly backsurface color as it was before,
6838 // we ignore old dump where r,g,b triple was set
6839 // - also we check that delta parameter is set properly
6840 if ( !rgbOk && deltaOk )
6843 else if ( type == "volume" ) {
6844 // volume color is set by 4 values r:g:b:delta, where
6845 // - r,g,b - is a normal volume rgb color components
6846 // - delta - is a reversed volume color delta coefficient
6847 if ( i+1 >= colors.count() ) break; // format error
6848 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6849 if ( i+2 >= colors.count() ) break; // format error
6850 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6851 if ( i+3 >= colors.count() ) break; // format error
6852 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6853 if ( i+4 >= colors.count() ) break; // format error
6854 int delta = colors[i+4].toInt( &bOk );
6855 if ( !bOk ) break; // format error
6856 volumeColor.setRgbF( r, g, b );
6860 else if ( type == "edge" ) {
6861 // edge color is set by 3 values r:g:b, where
6862 // - r,g,b - is rgb color components
6863 if ( i+1 >= colors.count() ) break; // format error
6864 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6865 if ( i+2 >= colors.count() ) break; // format error
6866 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6867 if ( i+3 >= colors.count() ) break; // format error
6868 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6869 edgeColor.setRgbF( r, g, b );
6872 else if ( type == "node" ) {
6873 // node color is set by 3 values r:g:b, where
6874 // - r,g,b - is rgb color components
6875 if ( i+1 >= colors.count() ) break; // format error
6876 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6877 if ( i+2 >= colors.count() ) break; // format error
6878 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6879 if ( i+3 >= colors.count() ) break; // format error
6880 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6881 nodeColor.setRgbF( r, g, b );
6884 else if ( type == "elem0d" ) {
6885 // 0d element color is set by 3 values r:g:b, where
6886 // - r,g,b - is rgb color components
6887 if ( i+1 >= colors.count() ) break; // format error
6888 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6889 if ( i+2 >= colors.count() ) break; // format error
6890 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6891 if ( i+3 >= colors.count() ) break; // format error
6892 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6893 elem0dColor.setRgbF( r, g, b );
6896 else if ( type == "ball" ) {
6897 // ball color is set by 3 values r:g:b, where
6898 // - r,g,b - is rgb color components
6899 if ( i+1 >= colors.count() ) break; // format error
6900 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6901 if ( i+2 >= colors.count() ) break; // format error
6902 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6903 if ( i+3 >= colors.count() ) break; // format error
6904 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6905 ballColor.setRgbF( r, g, b );
6908 else if ( type == "outline" ) {
6909 // outline color is set by 3 values r:g:b, where
6910 // - r,g,b - is rgb color components
6911 if ( i+1 >= colors.count() ) break; // format error
6912 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6913 if ( i+2 >= colors.count() ) break; // format error
6914 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6915 if ( i+3 >= colors.count() ) break; // format error
6916 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6917 outlineColor.setRgbF( r, g, b );
6920 else if ( type == "orientation" ) {
6921 // orientation color is set by 3 values r:g:b, where
6922 // - r,g,b - is rgb color components
6923 if ( i+1 >= colors.count() ) break; // format error
6924 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6925 if ( i+2 >= colors.count() ) break; // format error
6926 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6927 if ( i+3 >= colors.count() ) break; // format error
6928 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6929 orientationColor.setRgbF( r, g, b );
6934 if ( nodeColor.isValid() )
6935 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6937 if ( edgeColor.isValid() )
6938 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6940 if ( faceColor.isValid() )
6941 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6943 if ( volumeColor.isValid() )
6944 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6945 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6946 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6948 if ( elem0dColor.isValid() )
6949 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6951 if ( ballColor.isValid() )
6952 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6954 if ( outlineColor.isValid() )
6955 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6956 // orientation color
6957 if ( orientationColor.isValid() )
6958 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6961 else if (paramNameStr == "Sizes") {
6962 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6965 int outlineWidth = -1;
6966 int elem0dSize = -1;
6967 //int ballSize = -1;
6968 double ballDiameter = -1.0;
6969 double ballScale = -1.0;
6970 double shrinkSize = -1;
6971 double orientationSize = -1;
6972 bool orientation3d = false;
6973 for ( int i = 0; i < sizes.count(); i++ ) {
6974 QString type = sizes[i];
6975 if ( type == "line" ) {
6976 // line (wireframe) width is given as single integer value
6977 if ( i+1 >= sizes.count() ) break; // format error
6978 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6982 if ( type == "outline" ) {
6983 // outline width is given as single integer value
6984 if ( i+1 >= sizes.count() ) break; // format error
6985 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6989 else if ( type == "elem0d" ) {
6990 // 0d element size is given as single integer value
6991 if ( i+1 >= sizes.count() ) break; // format error
6992 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6996 else if ( type == "ball" ) {
6997 // balls are specified by two values: size:scale, where
6998 // - size - is a integer value specifying size
6999 // - scale - is a double value specifying scale factor
7000 if ( i+1 >= sizes.count() ) break; // format error
7001 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7002 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7003 if ( i+2 >= sizes.count() ) break; // format error
7004 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
7010 else if ( type == "shrink" ) {
7011 // shrink factor is given as single floating point value
7012 if ( i+1 >= sizes.count() ) break; // format error
7013 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7017 else if ( type == "orientation" ) {
7018 // orientation vectors are specified by two values size:3d, where
7019 // - size - is a floating point value specifying scale factor
7020 // - 3d - is a boolean
7021 if ( i+1 >= sizes.count() ) break; // format error
7022 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7023 if ( i+2 >= sizes.count() ) break; // format error
7024 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7025 orientationSize = v1;
7026 orientation3d = (bool)v2;
7030 // line (wireframe) width
7031 if ( lineWidth > 0 )
7032 aSmeshActor->SetLineWidth( lineWidth );
7034 if ( outlineWidth > 0 )
7035 aSmeshActor->SetOutlineWidth( outlineWidth );
7036 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7037 aSmeshActor->SetOutlineWidth( lineWidth );
7039 if ( elem0dSize > 0 )
7040 aSmeshActor->Set0DSize( elem0dSize );
7042 /*if ( ballSize > 0 )
7043 aSmeshActor->SetBallSize( ballSize );*/
7045 if ( ballDiameter > 0 )
7046 aSmeshActor->SetBallSize( ballDiameter );
7048 if ( ballScale > 0.0 )
7049 aSmeshActor->SetBallScale( ballScale );
7051 if ( shrinkSize > 0 )
7052 aSmeshActor->SetShrinkFactor( shrinkSize );
7053 // orientation vectors
7054 if ( orientationSize > 0 ) {
7055 aSmeshActor->SetFacesOrientationScale( orientationSize );
7056 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7060 else if (paramNameStr == "PointMarker") {
7061 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7062 if( data.count() >= 2 ) {
7064 int aParam1 = data[1].toInt( &ok );
7066 if( data[0] == "std" && data.count() == 3 ) {
7067 int aParam2 = data[2].toInt( &ok );
7068 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7070 else if( data[0] == "custom" ) {
7071 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7072 if( markerIt != myMarkerMap.end() ) {
7073 VTK::MarkerData aMarkerData = markerIt->second;
7074 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7081 else if (paramNameStr == "Opacity") {
7082 aSmeshActor->SetOpacity(val.toFloat());
7085 else if (paramNameStr.startsWith("ClippingPlane")) {
7086 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7087 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7088 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7089 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7090 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7091 // new format - val looks like "Off" or "0" (plane id)
7092 // (note: in new format "Off" value is used only for consistency,
7093 // so it is processed together with values in old format)
7094 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7095 if( anIsOldFormat ) {
7096 if (paramNameStr == "ClippingPlane1" || val == "Off")
7097 aSmeshActor->RemoveAllClippingPlanes();
7099 QList<SUIT_ViewManager*> lst;
7100 getApp()->viewManagers(viewerTypStr, lst);
7101 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7102 if (viewIndex >= 0 && viewIndex < lst.count()) {
7103 SUIT_ViewManager* vman = lst.at(viewIndex);
7104 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7106 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7108 SMESH::TActorList anActorList;
7109 anActorList.push_back( aSmeshActor );
7110 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7111 aPlane->myViewWindow = vtkView;
7112 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7113 aPlane->PlaneMode = aMode;
7114 bool isOpenGLClipping = ( bool )vals[1].toInt();
7115 aPlane->IsOpenGLClipping = isOpenGLClipping;
7116 if ( aMode == SMESH::Absolute ) {
7117 aPlane->myAbsoluteOrientation = vals[2].toInt();
7118 aPlane->X = vals[3].toFloat();
7119 aPlane->Y = vals[4].toFloat();
7120 aPlane->Z = vals[5].toFloat();
7121 aPlane->Dx = vals[6].toFloat();
7122 aPlane->Dy = vals[7].toFloat();
7123 aPlane->Dz = vals[8].toFloat();
7125 else if ( aMode == SMESH::Relative ) {
7126 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7127 aPlane->myDistance = vals[3].toFloat();
7128 aPlane->myAngle[0] = vals[4].toFloat();
7129 aPlane->myAngle[1] = vals[5].toFloat();
7133 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7134 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7135 aClippingPlaneInfo.Plane = aPlane;
7136 aClippingPlaneInfo.ActorList = anActorList;
7137 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7145 int aPlaneId = val.toInt( &ok );
7146 if( ok && aPlaneId >= 0 ) {
7147 bool anIsDefinedPlane = false;
7148 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7149 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7150 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7151 TPlaneInfo& aPlaneInfo = *anIter;
7152 if( aPlaneInfo.PlaneId == aPlaneId ) {
7153 aPlaneInfo.ActorList.push_back( aSmeshActor );
7154 anIsDefinedPlane = true;
7158 if( !anIsDefinedPlane ) {
7159 TPlaneInfo aPlaneInfo;
7160 aPlaneInfo.PlaneId = aPlaneId;
7161 aPlaneInfo.ActorList.push_back( aSmeshActor );
7162 aPlaneInfo.ViewManager = vman;
7164 // to make the list sorted by plane id
7165 anIter = aPlaneInfoList.begin();
7166 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7167 const TPlaneInfo& aPlaneInfoRef = *anIter;
7168 if( aPlaneInfoRef.PlaneId > aPlaneId )
7171 aPlaneInfoList.insert( anIter, aPlaneInfo );
7176 } // if (aSmeshActor)
7177 } // other parameters than Visibility
7179 } // for names/parameters iterator
7180 } // for entries iterator
7182 // take into account planes with empty list of actors referred to them
7183 QList<SUIT_ViewManager*> aVMList;
7184 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7186 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7187 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7188 int aViewId = aPlaneDataIter->first;
7189 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7190 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7192 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7194 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7195 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7196 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7197 const TPlaneData& aPlaneData = *anIter2;
7198 int aPlaneId = aPlaneData.Id;
7200 bool anIsFound = false;
7201 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7202 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7203 const TPlaneInfo& aPlaneInfo = *anIter3;
7204 if( aPlaneInfo.PlaneId == aPlaneId ) {
7211 TPlaneInfo aPlaneInfo; // ActorList field is empty
7212 aPlaneInfo.PlaneId = aPlaneId;
7213 aPlaneInfo.ViewManager = aViewManager;
7215 // to make the list sorted by plane id
7216 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7217 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7218 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7219 if( aPlaneInfoRef.PlaneId > aPlaneId )
7222 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7228 // add clipping planes to actors according to the restored parameters
7229 // and update the clipping plane map
7230 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7231 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7232 int aViewId = anIter1->first;
7233 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7235 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7236 if( anIter2 == aPlaneDataMap.end() )
7238 const TPlaneDataList& aPlaneDataList = anIter2->second;
7240 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7241 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7242 const TPlaneInfo& aPlaneInfo = *anIter3;
7243 int aPlaneId = aPlaneInfo.PlaneId;
7244 const TActorList& anActorList = aPlaneInfo.ActorList;
7245 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7249 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7253 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7255 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7256 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7257 const TPlaneData& aPlaneData = *anIter4;
7258 if( aPlaneData.Id == aPlaneId ) {
7259 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7260 aPlane->myViewWindow = aViewWindow;
7261 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7262 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7263 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7264 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7265 aPlane->X = aPlaneData.X;
7266 aPlane->Y = aPlaneData.Y;
7267 aPlane->Z = aPlaneData.Z;
7268 aPlane->Dx = aPlaneData.Dx;
7269 aPlane->Dy = aPlaneData.Dy;
7270 aPlane->Dz = aPlaneData.Dz;
7272 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7273 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7274 aPlane->myDistance = aPlaneData.Distance;
7275 aPlane->myAngle[0] = aPlaneData.Angle[0];
7276 aPlane->myAngle[1] = aPlaneData.Angle[1];
7279 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7280 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7281 aClippingPlaneInfo.Plane = aPlane;
7282 aClippingPlaneInfo.ActorList = anActorList;
7283 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7294 // update all VTK views
7295 QList<SUIT_ViewManager*> lst;
7296 getApp()->viewManagers(lst);
7297 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7298 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7299 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7300 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7301 // set OpenGL clipping planes
7302 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7303 vtkActorCollection* anAllActors = aCopy.GetActors();
7304 anAllActors->InitTraversal();
7305 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7306 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7307 anActor->SetOpenGLClippingPlane();
7309 vtkView->getRenderer()->ResetCameraClippingRange();
7316 \brief Adds preferences for dfont of VTK viewer
7318 \param pIf group identifier
7319 \param param parameter
7320 \return identifier of preferences
7322 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7324 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7326 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7329 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7330 fam.append( tr( "SMESH_FONT_COURIER" ) );
7331 fam.append( tr( "SMESH_FONT_TIMES" ) );
7333 setPreferenceProperty( tfont, "fonts", fam );
7335 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7336 if ( needSize ) f = f | QtxFontEdit::Size;
7337 setPreferenceProperty( tfont, "features", f );
7343 \brief Actions after hypothesis edition
7344 Updates object browser after hypothesis edition
7346 void SMESHGUI::onHypothesisEdit( int result )
7349 SMESHGUI::Modified();
7350 updateObjBrowser( true );
7354 \brief Actions after choosing menu of control modes
7355 Updates control mode actions according to current selection
7357 void SMESHGUI::onUpdateControlActions()
7359 SALOME_ListIO selected;
7360 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7361 aSel->selectedObjects( selected );
7363 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7364 if ( selected.Extent() ) {
7365 if ( selected.First()->hasEntry() ) {
7366 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7367 aControl = anActor->GetControlMode();
7368 SALOME_ListIteratorOfListIO it(selected);
7369 for ( it.Next(); it.More(); it.Next() ) {
7370 Handle(SALOME_InteractiveObject) anIO = it.Value();
7371 if ( anIO->hasEntry() ) {
7372 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7373 if ( aControl != anActor->GetControlMode() ) {
7374 aControl = SMESH_Actor::eNone;
7384 int anAction = ActionToControl( aControl, true );
7386 action( anAction )->setChecked( true );
7388 QMenu* send = (QMenu*)sender();
7389 QList<QAction*> actions = send->actions();
7390 for ( int i = 0; i < actions.size(); i++ )
7391 actions[i]->setChecked( false );
7397 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7398 \param pview view being closed
7400 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7401 #ifndef DISABLE_PLOT2DVIEWER
7402 //Crear all Plot2d Viewers if need.
7403 SMESH::ClearPlot2Viewers(pview);
7405 EmitSignalCloseView();
7408 void SMESHGUI::message( const QString& msg )
7411 QStringList data = msg.split("/");
7412 if ( data.count() > 0 ) {
7413 if ( data.first() == "mesh_loading" ) {
7415 QString entry = data.count() > 1 ? data[1] : QString();
7416 if ( entry.isEmpty() )
7419 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7421 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7424 name = SMESH::fromUtf8(obj->GetName());
7425 if ( name.isEmpty() )
7428 if ( data.last() == "stop" )
7429 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7431 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7432 QApplication::processEvents();
7438 \brief Connects or disconnects signals about activating and cloning view on the module slots
7439 \param pview view which is connected/disconnected
7441 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7445 SUIT_ViewManager* viewMgr = pview->getViewManager();
7447 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7448 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7450 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7451 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7456 \brief Return \c true if object can be renamed
7458 bool SMESHGUI::renameAllowed( const QString& entry) const {
7459 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7463 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7467 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7472 if(appStudy->isComponent(entry) || obj->isReference())
7475 // check type to prevent renaming of inappropriate objects
7476 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7477 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7478 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7479 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7480 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7481 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7488 Rename object by entry.
7489 \param entry entry of the object
7490 \param name new name of the object
7491 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7493 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7495 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7499 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7504 _PTR(Study) aStudy = appStudy->studyDS();
7509 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7511 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7516 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7517 _PTR(GenericAttribute) anAttr;
7518 _PTR(AttributeName) aName;
7520 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7522 // check type to prevent renaming of inappropriate objects
7523 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7524 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7525 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7526 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7527 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7528 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7529 if ( !name.isEmpty() ) {
7530 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7532 // update name of group object and its actor
7533 Handle(SALOME_InteractiveObject) IObject =
7534 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7536 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7537 if( !aGroupObject->_is_nil() ) {
7538 aGroupObject->SetName( qUtf8Printable(name) );
7539 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7540 anActor->setName( qUtf8Printable(name) );
7550 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7552 static QList<QColor> colors;
7554 if ( colors.isEmpty() ) {
7556 for (int s = 0; s < 2 ; s++)
7558 for (int v = 100; v >= 40; v = v - 20)
7560 for (int h = 0; h < 359 ; h = h + 60)
7562 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7567 static int currentColor = randomize( colors.size() );
7569 SALOMEDS::Color color;
7570 color.R = (double)colors[currentColor].red() / 255.0;
7571 color.G = (double)colors[currentColor].green() / 255.0;
7572 color.B = (double)colors[currentColor].blue() / 255.0;
7574 currentColor = (currentColor+1) % colors.count();