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 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2089 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2091 aStudyBuilder->RemoveObjectWithChildren( SO );
2095 } /* listSO back loop */
2097 aStudyBuilder->CommitCommand();
2099 /* Clear any previous selection */
2101 aSel->setSelectedObjects( l1 );
2103 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2107 SMESHGUI_EXPORT CAM_Module* createModule()
2109 return new SMESHGUI();
2112 SMESHGUI_EXPORT char* getModuleVersion() {
2113 return (char*)SMESH_VERSION_STR;
2117 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2119 //=============================================================================
2123 //=============================================================================
2124 SMESHGUI::SMESHGUI() : SalomeApp_Module( "SMESH" )
2126 if ( CORBA::is_nil( myComponentSMESH ) )
2128 CORBA::Boolean anIsEmbeddedMode;
2129 SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
2130 if( dynamic_cast<SALOME_NamingService *>(ns) )
2131 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2134 Engines::EngineComponent_var comp = RetrieveSMESHInstance();
2135 myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
2138 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2140 // 0019923: EDF 765 SMESH : default values of hypothesis
2141 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2142 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2143 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2144 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2145 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2147 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2148 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2149 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2151 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2152 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2156 myActiveDialogBox = 0;
2157 myFilterLibraryDlg = 0;
2161 myEventCallbackCommand = vtkCallbackCommand::New();
2162 myEventCallbackCommand->Delete();
2163 myEventCallbackCommand->SetClientData( this );
2164 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2167 /* load resources for all available meshers */
2168 SMESH::InitAvailableHypotheses();
2171 //=============================================================================
2175 //=============================================================================
2176 SMESHGUI::~SMESHGUI()
2180 //=============================================================================
2184 //=============================================================================
2185 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2187 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2189 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2194 //=============================================================================
2198 //=============================================================================
2199 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2201 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2205 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2206 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2207 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2208 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2209 return autoUpdate && !exceeded;
2212 //=============================================================================
2216 //=============================================================================
2217 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2218 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2220 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2224 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2225 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2226 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2228 SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
2229 long nbOdElems = info[SMDSEntity_0D];
2230 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2231 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2232 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2233 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2234 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2235 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2236 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2237 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2238 info[SMDSEntity_Polyhedra] +
2239 info[SMDSEntity_Hexagonal_Prism];
2240 long nbBalls = info[SMDSEntity_Ball];
2242 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2243 *nbElements = requestedSize;
2245 *entities = SMESH_Actor::eAllEntity;
2248 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2250 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2252 if ( incrementalLimit ) {
2255 if ( nbOdElems > 0 ) {
2256 if ( total + nbOdElems > updateLimit ) {
2257 *entities = *entities & ~SMESH_Actor::e0DElements;
2258 *hidden = *hidden | SMESH_Actor::e0DElements;
2265 if ( nbEdges > 0 ) {
2266 if ( total + nbEdges > updateLimit ) {
2267 *entities = *entities & ~SMESH_Actor::eEdges;
2268 *hidden = *hidden | SMESH_Actor::eEdges;
2275 if ( nbFaces > 0 ) {
2276 if ( total + nbFaces > updateLimit ) {
2277 *entities = *entities & ~SMESH_Actor::eFaces;
2278 *hidden = *hidden | SMESH_Actor::eFaces;
2285 if ( nbVolumes > 0 ) {
2286 if ( total + nbVolumes > updateLimit ) {
2287 *entities = *entities & ~SMESH_Actor::eVolumes;
2288 *hidden = *hidden | SMESH_Actor::eVolumes;
2295 if ( nbBalls > 0 ) {
2296 if ( total + nbBalls > updateLimit ) {
2297 *entities = *entities & ~SMESH_Actor::eBallElem;
2298 *hidden = *hidden | SMESH_Actor::eBallElem;
2306 return autoUpdate && !exceeded;
2309 //=============================================================================
2313 //=============================================================================
2314 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2316 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2319 //=============================================================================
2323 //=============================================================================
2324 SMESHGUI* SMESHGUI::GetSMESHGUI()
2326 SMESHGUI* smeshMod = 0;
2327 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2330 CAM_Module* module = app->module( "Mesh" );
2331 smeshMod = dynamic_cast<SMESHGUI*>( module );
2339 Standard_EXPORT SMESHGUI* GetComponentGUI()
2341 return SMESHGUI::GetSMESHGUI();
2345 //=============================================================================
2349 //=============================================================================
2350 void SMESHGUI::SetState(int aState)
2355 //=============================================================================
2359 //=============================================================================
2360 void SMESHGUI::ResetState()
2365 //=============================================================================
2369 //=============================================================================
2370 void SMESHGUI::EmitSignalDeactivateDialog()
2372 emit SignalDeactivateActiveDialog();
2375 //=============================================================================
2379 //=============================================================================
2380 void SMESHGUI::EmitSignalStudyFrameChanged()
2382 emit SignalStudyFrameChanged();
2385 //=============================================================================
2389 //=============================================================================
2390 void SMESHGUI::EmitSignalCloseAllDialogs()
2392 emit SignalCloseAllDialogs();
2395 //=============================================================================
2399 //=============================================================================
2400 void SMESHGUI::EmitSignalVisibilityChanged()
2402 emit SignalVisibilityChanged();
2405 //=============================================================================
2409 //=============================================================================
2410 void SMESHGUI::EmitSignalCloseView()
2412 emit SignalCloseView();
2415 //=============================================================================
2419 //=============================================================================
2420 void SMESHGUI::EmitSignalActivatedViewManager()
2422 emit SignalActivatedViewManager();
2425 //=============================================================================
2429 //=============================================================================
2430 QDialog *SMESHGUI::GetActiveDialogBox()
2432 return myActiveDialogBox;
2435 //=============================================================================
2439 //=============================================================================
2440 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2442 myActiveDialogBox = (QDialog *) aDlg;
2446 //=============================================================================
2450 //=============================================================================
2451 SUIT_Desktop* SMESHGUI::desktop()
2453 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2455 return app->desktop();
2460 //=============================================================================
2464 //=============================================================================
2465 SalomeApp_Study* SMESHGUI::activeStudy()
2467 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2469 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2474 //=============================================================================
2478 //=============================================================================
2479 void SMESHGUI::Modified( bool theIsUpdateActions )
2481 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2482 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2483 appStudy->Modified();
2484 if( theIsUpdateActions )
2485 app->updateActions();
2490 //=============================================================================
2494 //=============================================================================
2495 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2497 /* Here the position is on the bottom right corner - 10 */
2498 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2500 SUIT_Desktop *PP = desktop();
2501 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2502 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2507 * \brief Verifies whether study of operation is locked
2508 * \param theMess - specifies whether message box must be shown if study is locked
2509 * \return State of study.
2511 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2512 * is locked when corresponding message box appears
2514 bool SMESHGUI::isStudyLocked( bool theMessage )
2516 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2519 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2520 QObject::tr( "WRN_WARNING" ),
2521 QObject::tr( "WRN_STUDY_LOCKED" ) );
2527 //=============================================================================
2531 //=============================================================================
2532 bool SMESHGUI::OnGUIEvent( int theCommandID )
2534 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2538 SUIT_ResourceMgr* mgr = resourceMgr();
2542 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2543 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2545 //QAction* act = action( theCommandID );
2547 switch (theCommandID) {
2548 case SMESHOp::OpDelete:
2549 if(isStudyLocked()) break;
2552 case SMESHOp::OpImportDAT:
2553 case SMESHOp::OpImportUNV:
2554 case SMESHOp::OpImportMED:
2555 case SMESHOp::OpImportSTL:
2556 case SMESHOp::OpImportCGNS:
2557 case SMESHOp::OpImportGMF:
2558 case SMESHOp::OpPopupImportDAT:
2559 case SMESHOp::OpPopupImportUNV:
2560 case SMESHOp::OpPopupImportMED:
2561 case SMESHOp::OpPopupImportSTL:
2562 case SMESHOp::OpPopupImportCGNS:
2563 case SMESHOp::OpPopupImportGMF:
2565 if(isStudyLocked()) break;
2566 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2570 case SMESHOp::OpFileInformation:
2572 SALOME_ListIO selected;
2573 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2575 aSel->selectedObjects( selected );
2576 if( selected.Extent() )
2578 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2579 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2580 if ( !aMesh->_is_nil() )
2582 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2588 case SMESHOp::OpExportDAT:
2589 case SMESHOp::OpExportMED:
2590 case SMESHOp::OpExportUNV:
2591 case SMESHOp::OpExportSTL:
2592 case SMESHOp::OpExportCGNS:
2593 case SMESHOp::OpExportGMF:
2594 case SMESHOp::OpPopupExportDAT:
2595 case SMESHOp::OpPopupExportMED:
2596 case SMESHOp::OpPopupExportUNV:
2597 case SMESHOp::OpPopupExportSTL:
2598 case SMESHOp::OpPopupExportCGNS:
2599 case SMESHOp::OpPopupExportGMF:
2601 ::ExportMeshToFile(theCommandID);
2605 case SMESHOp::OpReset: // SCALAR BAR
2607 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2608 SALOME_ListIO selected;
2610 aSel->selectedObjects( selected );
2612 SALOME_ListIteratorOfListIO it(selected);
2613 for( ; it.More(); it.Next()) {
2614 Handle(SALOME_InteractiveObject) anIO = it.Value();
2615 if( anIO->hasEntry() ) {
2616 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2617 anActor->SetControlMode( SMESH_Actor::eNone );
2618 #ifndef DISABLE_PLOT2DVIEWER
2619 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2621 anActor->UpdateFilter();
2625 SMESH::UpdateView();
2628 case SMESHOp::OpScalarBarProperties:
2630 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2633 case SMESHOp::OpShowScalarBar:
2635 // show/hide scalar bar
2636 ::ShowElement(theCommandID);
2639 case SMESHOp::OpSaveDistribution:
2641 // dump control distribution data to the text file
2642 ::SaveDistribution();
2646 case SMESHOp::OpShowDistribution:
2648 // show/hide distribution
2649 ::ShowElement(theCommandID);
2653 #ifndef DISABLE_PLOT2DVIEWER
2654 case SMESHOp::OpPlotDistribution:
2656 // plot distribution
2657 ::PlotDistribution();
2663 case SMESHOp::OpAutoColor:
2667 case SMESHOp::OpDisableAutoColor:
2668 ::DisableAutoColor();
2671 case SMESHOp::OpClipping:
2672 case SMESHOp::OpTransparency:
2673 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2676 case SMESHOp::OpDMWireframe:
2677 case SMESHOp::OpDMShading:
2678 case SMESHOp::OpDMNodes:
2679 case SMESHOp::OpDMShrink:
2680 ::SetDisplayMode(theCommandID, myMarkerMap);
2683 //2D quadratic representation
2684 case SMESHOp::OpRepresentationLines:
2685 case SMESHOp::OpRepresentationArcs:
2686 ::SetDisplayMode(theCommandID, myMarkerMap);
2690 case SMESHOp::OpDE0DElements:
2691 case SMESHOp::OpDEEdges:
2692 case SMESHOp::OpDEFaces:
2693 case SMESHOp::OpDEVolumes:
2694 case SMESHOp::OpDEBalls:
2695 case SMESHOp::OpDEAllEntity:
2696 ::SetDisplayEntity(theCommandID);
2699 // Choose entities to be displayed
2700 case SMESHOp::OpDEChoose:
2702 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2706 case SMESHOp::OpOrientationOnFaces:
2708 SUIT_OverrideCursor wc;
2709 LightApp_SelectionMgr* mgr = selectionMgr();
2710 SALOME_ListIO selected; mgr->selectedObjects( selected );
2712 SALOME_ListIteratorOfListIO it(selected);
2713 for( ; it.More(); it.Next()) {
2714 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2715 if(anIObject->hasEntry()) {
2716 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2717 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2724 case SMESHOp::OpUpdate:
2726 if(isStudyLocked()) break;
2727 SUIT_OverrideCursor wc;
2730 SMESH::UpdateView();
2732 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2733 SMESH::OnVisuException();
2735 catch (...) { // PAL16774 (Crash after display of many groups)
2736 SMESH::OnVisuException();
2740 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2741 aSel->selectedObjects( l );
2742 aSel->setSelectedObjects( l );
2746 case SMESHOp::OpHide:
2747 case SMESHOp::OpShow:
2748 case SMESHOp::OpShowOnly:
2750 SUIT_OverrideCursor wc;
2751 SMESH::EDisplaing anAction;
2752 switch (theCommandID) {
2753 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2754 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2755 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2758 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2759 SALOME_ListIO sel_objects, to_process;
2761 aSel->selectedObjects( sel_objects );
2763 if ( theCommandID==SMESHOp::OpShowOnly )
2765 //MESSAGE("anAction = SMESH::eDisplayOnly");
2766 startOperation( myEraseAll );
2769 extractContainers( sel_objects, to_process );
2774 SALOME_ListIteratorOfListIO It( to_process );
2775 for ( ; It.More(); It.Next())
2777 Handle(SALOME_InteractiveObject) IOS = It.Value();
2778 if ( IOS->hasEntry() )
2780 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2781 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2782 break; // PAL16774 (Crash after display of many groups)
2784 if (anAction == SMESH::eDisplayOnly)
2785 anAction = SMESH::eDisplay;
2790 // PAL13338 + PAL15161 -->
2791 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2792 SMESH::UpdateView();
2793 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2795 // PAL13338 + PAL15161 <--
2797 catch (...) { // PAL16774 (Crash after display of many groups)
2798 SMESH::OnVisuException();
2801 if (anAction == SMESH::eErase) {
2803 aSel->setSelectedObjects( l1 );
2806 aSel->setSelectedObjects( to_process );
2808 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2809 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2810 vtkwnd->GetRenderer()->AdjustActors();
2815 case SMESHOp::OpNode:
2817 if(isStudyLocked()) break;
2820 EmitSignalDeactivateDialog();
2822 ( new SMESHGUI_NodesDlg( this ) )->show();
2825 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2830 case SMESHOp::OpEditMeshOrSubMesh:
2831 case SMESHOp::OpEditMesh:
2832 case SMESHOp::OpEditSubMesh:
2833 case SMESHOp::OpMeshOrder:
2834 case SMESHOp::OpCreateSubMesh:
2835 if ( warnOnGeomModif() )
2836 break; // action forbidden as geometry modified
2838 case SMESHOp::OpCreateMesh:
2839 case SMESHOp::OpCompute:
2840 case SMESHOp::OpComputeSubMesh:
2841 case SMESHOp::OpPreCompute:
2842 case SMESHOp::OpEvaluate:
2843 case SMESHOp::OpShowErrors:
2844 startOperation( theCommandID );
2846 case SMESHOp::OpRecompute:
2848 if ( isStudyLocked() )
2850 SALOME_ListIO selected;
2851 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2852 sel->selectedObjects( selected );
2853 if ( selected.Extent() == 1 ) {
2854 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2855 if ( !aMesh->_is_nil() )
2857 startOperation( SMESHOp::OpCompute );
2861 case SMESHOp::OpCopyMesh:
2863 if (isStudyLocked()) break;
2864 EmitSignalDeactivateDialog();
2865 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2868 case SMESHOp::OpBuildCompoundMesh:
2870 if (isStudyLocked()) break;
2871 EmitSignalDeactivateDialog();
2872 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2876 case SMESHOp::OpDiagonalInversion:
2877 case SMESHOp::OpUnionOfTwoTriangle:
2881 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2885 if ( isStudyLocked() )
2887 if ( warnOnGeomModif() )
2888 break; // action forbidden as geometry modified
2890 /*Standard_Boolean aRes;
2891 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2892 if ( aMesh->_is_nil() )
2894 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2895 tr( "SMESH_BAD_SELECTION" ) );
2899 EmitSignalDeactivateDialog();
2900 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2901 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2903 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2906 case SMESHOp::OpOrientation:
2907 case SMESHOp::OpUnionOfTriangles:
2908 case SMESHOp::OpCuttingOfQuadrangles:
2909 case SMESHOp::OpSplitVolumes:
2913 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2917 if ( isStudyLocked() )
2919 if ( warnOnGeomModif() )
2920 break; // action forbidden as geometry modified
2922 EmitSignalDeactivateDialog();
2923 SMESHGUI_MultiEditDlg* aDlg = NULL;
2924 if ( theCommandID == SMESHOp::OpOrientation )
2925 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2926 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2927 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2928 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2929 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2931 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2936 case SMESHOp::OpSmoothing:
2938 if(isStudyLocked()) break;
2939 if ( warnOnGeomModif() )
2940 break; // action forbidden as geometry modified
2942 EmitSignalDeactivateDialog();
2943 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2946 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2950 case SMESHOp::OpExtrusion:
2952 if (isStudyLocked()) break;
2953 if ( warnOnGeomModif() )
2954 break; // action forbidden as geometry modified
2956 EmitSignalDeactivateDialog();
2957 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2959 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2963 case SMESHOp::OpExtrusionAlongAPath:
2965 if (isStudyLocked()) break;
2966 if ( warnOnGeomModif() )
2967 break; // action forbidden as geometry modified
2969 EmitSignalDeactivateDialog();
2970 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2972 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2976 case SMESHOp::OpRevolution:
2978 if(isStudyLocked()) break;
2979 if ( warnOnGeomModif() )
2980 break; // action forbidden as geometry modified
2982 EmitSignalDeactivateDialog();
2983 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2986 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2990 case SMESHOp::OpPatternMapping:
2992 if ( isStudyLocked() )
2994 if ( warnOnGeomModif() )
2995 break; // action forbidden as geometry modified
2998 EmitSignalDeactivateDialog();
2999 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3002 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3006 // Adaptation - begin
3007 #ifndef DISABLE_MG_ADAPT
3008 case SMESHOp::OpMGAdapt:
3010 if ( isStudyLocked() )
3012 EmitSignalDeactivateDialog();
3014 SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
3015 bool isCreation = false;
3016 ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
3020 case SMESHOp::OpHomardAdapt:
3022 if ( isStudyLocked() )
3024 EmitSignalDeactivateDialog();
3026 SALOME::GenericObj_wrap< SMESHHOMARD::HOMARD_Gen > homardGen;
3028 homardGen = GetSMESHGen()->CreateHOMARD_ADAPT();
3030 catch ( const SALOME::SALOME_Exception& S_ex ) {
3031 SUIT_MessageBox::critical(SMESHGUI::desktop(),
3032 QObject::tr("SMESH_ERROR"),
3033 QObject::tr(S_ex.details.text.in()));
3035 if (!homardGen->_is_nil()) {
3036 SMESHGUI_HomardAdaptDlg *aDlg = new SMESHGUI_HomardAdaptDlg(homardGen);
3042 case SMESHOp::OpSplitBiQuadratic:
3043 case SMESHOp::OpConvertMeshToQuadratic:
3044 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3045 case SMESHOp::OpReorientFaces:
3046 case SMESHOp::OpCreateGeometryGroup:
3048 if ( warnOnGeomModif() )
3049 break; // action forbidden as geometry modified
3050 startOperation( theCommandID );
3053 case SMESHOp::OpCreateGroup:
3057 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3061 if(isStudyLocked()) break;
3062 if ( warnOnGeomModif() )
3063 break; // action forbidden as geometry modified
3064 EmitSignalDeactivateDialog();
3065 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3067 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3068 SALOME_ListIO selected;
3070 aSel->selectedObjects( selected );
3072 int nbSel = selected.Extent();
3074 // check if mesh is selected
3075 aMesh = SMESH::GetMeshByIO( selected.First() );
3077 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3082 case SMESHOp::OpConstructGroup:
3086 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3090 if(isStudyLocked()) break;
3091 if ( warnOnGeomModif() )
3092 break; // action forbidden as geometry modified
3093 EmitSignalDeactivateDialog();
3095 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3096 SALOME_ListIO selected;
3098 aSel->selectedObjects( selected );
3100 int nbSel = selected.Extent();
3102 // check if submesh is selected
3103 Handle(SALOME_InteractiveObject) IObject = selected.First();
3104 if (IObject->hasEntry()) {
3105 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3107 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3108 if (!aSubMesh->_is_nil()) {
3110 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3111 // get submesh elements list by types
3112 SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3113 SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3114 SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3115 SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3116 // create group for each type o elements
3117 QString aName = IObject->getName();
3118 QStringList anEntryList;
3119 if (aNodes->length() > 0) {
3120 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3121 aGroup->Add(aNodes.inout());
3122 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3123 anEntryList.append( aSObject->GetID().c_str() );
3125 if (aEdges->length() > 0) {
3126 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3127 aGroup->Add(aEdges.inout());
3128 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3129 anEntryList.append( aSObject->GetID().c_str() );
3131 if (aFaces->length() > 0) {
3132 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3133 aGroup->Add(aFaces.inout());
3134 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3135 anEntryList.append( aSObject->GetID().c_str() );
3137 if (aVolumes->length() > 0) {
3138 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3139 aGroup->Add(aVolumes.inout());
3140 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3141 anEntryList.append( aSObject->GetID().c_str() );
3144 anApp->browseObjects( anEntryList );
3146 catch(const SALOME::SALOME_Exception & S_ex){
3147 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3154 SUIT_MessageBox::warning(desktop(),
3155 tr("SMESH_WRN_WARNING"),
3156 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3161 case SMESHOp::OpEditGroup:
3165 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3169 if(isStudyLocked()) break;
3170 if ( warnOnGeomModif() )
3171 break; // action forbidden as geometry modified
3172 EmitSignalDeactivateDialog();
3174 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3175 SALOME_ListIO selected;
3177 aSel->selectedObjects( selected );
3179 SALOME_ListIteratorOfListIO It (selected);
3180 int nbSelectedGroups = 0;
3181 for ( ; It.More(); It.Next() )
3183 SMESH::SMESH_GroupBase_var aGroup =
3184 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3185 if (!aGroup->_is_nil()) {
3187 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3191 if (nbSelectedGroups == 0)
3193 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3199 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3201 if(isStudyLocked()) break;
3202 if (myState == 800) {
3203 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3204 if (aDlg) aDlg->onAdd();
3209 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3211 if(isStudyLocked()) break;
3212 if (myState == 800) {
3213 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3214 if (aDlg) aDlg->onRemove();
3219 case SMESHOp::OpEditGeomGroupAsGroup:
3223 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3227 if(isStudyLocked()) break;
3228 EmitSignalDeactivateDialog();
3230 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3231 SALOME_ListIO selected;
3233 aSel->selectedObjects( selected );
3235 SALOME_ListIteratorOfListIO It (selected);
3236 for ( ; It.More(); It.Next() )
3238 SMESH::SMESH_GroupOnGeom_var aGroup =
3239 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3240 if (!aGroup->_is_nil()) {
3241 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3246 SMESH::SMESH_GroupOnFilter_var aGroup =
3247 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3248 if (!aGroup->_is_nil()) {
3249 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3257 case SMESHOp::OpUnionGroups:
3258 case SMESHOp::OpIntersectGroups:
3259 case SMESHOp::OpCutGroups:
3263 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3267 if ( isStudyLocked() )
3269 if ( warnOnGeomModif() )
3270 break; // action forbidden as geometry modified
3272 EmitSignalDeactivateDialog();
3274 SMESHGUI_GroupOpDlg* aDlg = 0;
3275 if ( theCommandID == SMESHOp::OpUnionGroups )
3276 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3277 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3278 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3280 aDlg = new SMESHGUI_CutGroupsDlg( this );
3287 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3289 if ( isStudyLocked() )
3291 if ( warnOnGeomModif() )
3292 break; // action forbidden as geometry modified
3294 EmitSignalDeactivateDialog();
3295 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3301 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3303 if ( isStudyLocked() )
3305 if ( warnOnGeomModif() )
3306 break; // action forbidden as geometry modified
3308 EmitSignalDeactivateDialog();
3309 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3315 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3319 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3323 if ( isStudyLocked() )
3326 EmitSignalDeactivateDialog();
3328 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3332 case SMESHOp::OpMeshInformation:
3333 case SMESHOp::OpWhatIs:
3335 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3336 EmitSignalDeactivateDialog();
3337 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3338 SALOME_ListIO selected;
3340 aSel->selectedObjects( selected );
3342 if ( selected.Extent() > 1 ) { // a dlg for each IO
3343 SALOME_ListIteratorOfListIO It( selected );
3344 for ( ; It.More(); It.Next() ) {
3345 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3346 dlg->showInfo( It.Value() );
3351 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3357 case SMESHOp::OpFindElementByPoint:
3359 startOperation( theCommandID );
3363 case SMESHOp::OpEditHypothesis:
3365 if(isStudyLocked()) break;
3366 if ( warnOnGeomModif() )
3367 break; // action forbidden as geometry modified
3369 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3370 SALOME_ListIO selected;
3372 aSel->selectedObjects( selected );
3374 int nbSel = selected.Extent();
3377 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3378 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3380 if ( !aHypothesis->_is_nil() )
3382 SMESHGUI_GenericHypothesisCreator* aCreator =
3383 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3386 // set geometry of mesh and sub-mesh to aCreator
3387 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3388 if ( selected.Extent() == 1 )
3390 QString subGeomID, meshGeomID;
3391 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3392 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3394 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3395 aCreator->setShapeEntry( subGeomID );
3396 aCreator->setMainShapeEntry( meshGeomID );
3400 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3410 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3412 if(isStudyLocked()) break;
3413 if ( warnOnGeomModif() )
3414 break; // action forbidden as geometry modified
3415 SUIT_OverrideCursor wc;
3417 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3418 SALOME_ListIO selected;
3420 aSel->selectedObjects( selected, QString::null, false );
3422 SALOME_ListIteratorOfListIO It(selected);
3423 for (int i = 0; It.More(); It.Next(), i++) {
3424 Handle(SALOME_InteractiveObject) IObject = It.Value();
3425 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3428 aSel->setSelectedObjects( l1 );
3433 case SMESHOp::OpElem0D:
3434 case SMESHOp::OpBall:
3435 case SMESHOp::OpEdge:
3436 case SMESHOp::OpTriangle:
3437 case SMESHOp::OpQuadrangle:
3438 case SMESHOp::OpPolygon:
3439 case SMESHOp::OpTetrahedron:
3440 case SMESHOp::OpHexahedron:
3441 case SMESHOp::OpPentahedron:
3442 case SMESHOp::OpPyramid:
3443 case SMESHOp::OpHexagonalPrism:
3445 if(isStudyLocked()) break;
3446 if ( warnOnGeomModif() )
3447 break; // action forbidden as geometry modified
3449 EmitSignalDeactivateDialog();
3450 SMDSAbs_EntityType type = SMDSEntity_Edge;
3451 switch (theCommandID) {
3452 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3453 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3454 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3455 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3456 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3457 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3458 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3459 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3460 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3461 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3464 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3467 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3471 case SMESHOp::OpPolyhedron:
3473 if(isStudyLocked()) break;
3474 if ( warnOnGeomModif() )
3475 break; // action forbidden as geometry modified
3477 EmitSignalDeactivateDialog();
3478 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3481 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3485 case SMESHOp::OpQuadraticEdge:
3486 case SMESHOp::OpQuadraticTriangle:
3487 case SMESHOp::OpBiQuadraticTriangle:
3488 case SMESHOp::OpQuadraticQuadrangle:
3489 case SMESHOp::OpBiQuadraticQuadrangle:
3490 case SMESHOp::OpQuadraticPolygon:
3491 case SMESHOp::OpQuadraticTetrahedron:
3492 case SMESHOp::OpQuadraticPyramid:
3493 case SMESHOp::OpQuadraticPentahedron:
3494 case SMESHOp::OpBiQuadraticPentahedron:
3495 case SMESHOp::OpQuadraticHexahedron:
3496 case SMESHOp::OpTriQuadraticHexahedron:
3498 if(isStudyLocked()) break;
3499 if ( warnOnGeomModif() )
3500 break; // action forbidden as geometry modified
3502 EmitSignalDeactivateDialog();
3503 SMDSAbs_EntityType type = SMDSEntity_Last;
3505 switch (theCommandID) {
3506 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3507 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3508 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3509 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3510 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3511 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3512 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3513 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3514 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3515 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3516 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3517 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3520 if ( type != SMDSEntity_Last )
3521 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3524 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3525 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3529 case SMESHOp::OpRemoveNodes:
3531 if(isStudyLocked()) break;
3532 if ( warnOnGeomModif() )
3533 break; // action forbidden as geometry modified
3535 EmitSignalDeactivateDialog();
3536 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3539 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3540 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3544 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3546 if(isStudyLocked()) break;
3547 if ( warnOnGeomModif() )
3548 break; // action forbidden as geometry modified
3550 EmitSignalDeactivateDialog();
3551 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3555 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3556 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3560 case SMESHOp::OpClearMesh: {
3562 if(isStudyLocked()) break;
3563 if ( warnOnGeomModif() )
3564 break; // action forbidden as geometry modified
3566 SALOME_ListIO selected;
3567 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3568 aSel->selectedObjects( selected );
3570 SUIT_OverrideCursor wc;
3571 SALOME_ListIteratorOfListIO It (selected);
3572 for ( ; It.More(); It.Next() )
3574 Handle(SALOME_InteractiveObject) IOS = It.Value();
3575 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3576 if ( aMesh->_is_nil()) continue;
3579 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3580 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3581 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3582 // hide groups and submeshes
3583 _PTR(ChildIterator) anIter =
3584 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3585 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3587 _PTR(SObject) so = anIter->Value();
3588 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3591 catch (const SALOME::SALOME_Exception& S_ex){
3593 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3597 SMESH::UpdateView();
3601 case SMESHOp::OpRemoveOrphanNodes:
3603 if(isStudyLocked()) break;
3604 if ( warnOnGeomModif() )
3605 break; // action forbidden as geometry modified
3606 SALOME_ListIO selected;
3607 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3608 aSel->selectedObjects( selected );
3609 if ( selected.Extent() == 1 ) {
3610 Handle(SALOME_InteractiveObject) anIO = selected.First();
3611 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3612 if ( !aMesh->_is_nil() ) {
3613 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3614 tr( "SMESH_WARNING" ),
3615 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3616 SUIT_MessageBox::Yes |
3617 SUIT_MessageBox::No,
3618 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3621 SUIT_OverrideCursor wc;
3622 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3623 smIdType removed = aMeshEditor->RemoveOrphanNodes();
3624 SUIT_MessageBox::information(SMESHGUI::desktop(),
3625 tr("SMESH_INFORMATION"),
3626 tr("NB_NODES_REMOVED").arg(removed));
3627 if ( removed > 0 ) {
3628 SMESH::UpdateView();
3629 SMESHGUI::Modified();
3632 catch (const SALOME::SALOME_Exception& S_ex) {
3633 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3642 case SMESHOp::OpRenumberingNodes:
3644 if(isStudyLocked()) break;
3645 if ( warnOnGeomModif() )
3646 break; // action forbidden as geometry modified
3648 EmitSignalDeactivateDialog();
3649 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3653 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3654 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3658 case SMESHOp::OpRenumberingElements:
3660 if(isStudyLocked()) break;
3661 if ( warnOnGeomModif() )
3662 break; // action forbidden as geometry modified
3664 EmitSignalDeactivateDialog();
3665 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3669 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3670 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3674 case SMESHOp::OpTranslation:
3676 if(isStudyLocked()) break;
3677 if ( warnOnGeomModif() )
3678 break; // action forbidden as geometry modified
3680 EmitSignalDeactivateDialog();
3681 ( new SMESHGUI_TranslationDlg( this ) )->show();
3684 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3685 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3689 case SMESHOp::OpRotation:
3691 if(isStudyLocked()) break;
3692 if ( warnOnGeomModif() )
3693 break; // action forbidden as geometry modified
3695 EmitSignalDeactivateDialog();
3696 ( new SMESHGUI_RotationDlg( this ) )->show();
3699 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3700 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3704 case SMESHOp::OpSymmetry:
3706 if(isStudyLocked()) break;
3707 if ( warnOnGeomModif() )
3708 break; // action forbidden as geometry modified
3710 EmitSignalDeactivateDialog();
3711 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3714 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3715 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3719 case SMESHOp::OpScale:
3721 if(isStudyLocked()) break;
3722 if ( warnOnGeomModif() )
3723 break; // action forbidden as geometry modified
3725 EmitSignalDeactivateDialog();
3726 ( new SMESHGUI_ScaleDlg( this ) )->show();
3729 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3730 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3735 case SMESHOp::OpOffset:
3737 if(isStudyLocked()) break;
3738 if ( warnOnGeomModif() )
3739 break; // action forbidden as geometry modified
3741 EmitSignalDeactivateDialog();
3742 ( new SMESHGUI_OffsetDlg( this ) )->show();
3745 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3746 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3751 case SMESHOp::OpSewing:
3753 if(isStudyLocked()) break;
3754 if ( warnOnGeomModif() )
3755 break; // action forbidden as geometry modified
3757 EmitSignalDeactivateDialog();
3758 ( new SMESHGUI_SewingDlg( this ) )->show();
3761 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3762 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3766 case SMESHOp::OpMergeNodes:
3768 if(isStudyLocked()) break;
3769 if ( warnOnGeomModif() )
3770 break; // action forbidden as geometry modified
3772 EmitSignalDeactivateDialog();
3773 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3776 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3777 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3781 case SMESHOp::OpMergeElements:
3783 if (isStudyLocked()) break;
3784 if ( warnOnGeomModif() )
3785 break; // action forbidden as geometry modified
3787 EmitSignalDeactivateDialog();
3788 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3790 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3791 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3796 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3797 if ( warnOnGeomModif() )
3798 break; // action forbidden as geometry modified
3799 startOperation( SMESHOp::OpMoveNode );
3802 case SMESHOp::OpDuplicateNodes:
3804 if(isStudyLocked()) break;
3805 if ( warnOnGeomModif() )
3806 break; // action forbidden as geometry modified
3808 EmitSignalDeactivateDialog();
3809 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3812 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3813 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3818 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3819 if ( warnOnGeomModif() )
3820 break; // action forbidden as geometry modified
3821 startOperation( SMESHOp::OpElem0DOnElemNodes );
3824 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3826 static QList<int> aTypes;
3827 if ( aTypes.isEmpty() )
3829 aTypes.append( SMESH::NODE );
3830 aTypes.append( SMESH::EDGE );
3831 aTypes.append( SMESH::FACE );
3832 aTypes.append( SMESH::VOLUME );
3834 if (!myFilterLibraryDlg)
3835 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3836 else if (myFilterLibraryDlg->isHidden())
3837 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3838 myFilterLibraryDlg->raise();
3842 case SMESHOp::OpFreeNode:
3843 case SMESHOp::OpEqualNode:
3844 case SMESHOp::OpNodeConnectivityNb:
3845 case SMESHOp::OpFreeEdge:
3846 case SMESHOp::OpFreeBorder:
3847 case SMESHOp::OpLength:
3848 case SMESHOp::OpConnection:
3849 case SMESHOp::OpEqualEdge:
3850 case SMESHOp::OpFreeFace:
3851 case SMESHOp::OpBareBorderFace:
3852 case SMESHOp::OpOverConstrainedFace:
3853 case SMESHOp::OpLength2D:
3854 case SMESHOp::OpDeflection2D:
3855 case SMESHOp::OpConnection2D:
3856 case SMESHOp::OpArea:
3857 case SMESHOp::OpTaper:
3858 case SMESHOp::OpAspectRatio:
3859 case SMESHOp::OpMinimumAngle:
3860 case SMESHOp::OpWarpingAngle:
3861 case SMESHOp::OpSkew:
3862 case SMESHOp::OpMaxElementLength2D:
3863 case SMESHOp::OpEqualFace:
3864 case SMESHOp::OpAspectRatio3D:
3865 case SMESHOp::OpVolume:
3866 case SMESHOp::OpMaxElementLength3D:
3867 case SMESHOp::OpBareBorderVolume:
3868 case SMESHOp::OpOverConstrainedVolume:
3869 case SMESHOp::OpEqualVolume:
3872 LightApp_SelectionMgr* mgr = selectionMgr();
3873 SALOME_ListIO selected; mgr->selectedObjects( selected );
3875 if( !selected.IsEmpty() ) {
3876 SUIT_OverrideCursor wc;
3877 ::Control( theCommandID );
3880 SUIT_MessageBox::warning(desktop(),
3881 tr( "SMESH_WRN_WARNING" ),
3882 tr( "SMESH_BAD_SELECTION" ) );
3886 SUIT_MessageBox::warning(desktop(),
3887 tr( "SMESH_WRN_WARNING" ),
3888 tr( "NOT_A_VTK_VIEWER" ) );
3891 case SMESHOp::OpOverallMeshQuality:
3892 OverallMeshQuality();
3894 case SMESHOp::OpNumberingNodes:
3896 SUIT_OverrideCursor wc;
3897 LightApp_SelectionMgr* mgr = selectionMgr();
3898 SALOME_ListIO selected; mgr->selectedObjects( selected );
3900 SALOME_ListIteratorOfListIO it(selected);
3901 for( ; it.More(); it.Next()) {
3902 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3903 if(anIObject->hasEntry()) {
3904 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3905 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3911 case SMESHOp::OpNumberingElements:
3913 SUIT_OverrideCursor wc;
3914 LightApp_SelectionMgr* mgr = selectionMgr();
3915 SALOME_ListIO selected; mgr->selectedObjects( selected );
3917 SALOME_ListIteratorOfListIO it(selected);
3918 for( ; it.More(); it.Next()) {
3919 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3920 if(anIObject->hasEntry())
3921 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3922 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3927 case SMESHOp::OpPropertiesLength:
3928 case SMESHOp::OpPropertiesArea:
3929 case SMESHOp::OpPropertiesVolume:
3930 case SMESHOp::OpMinimumDistance:
3931 case SMESHOp::OpBoundingBox:
3932 case SMESHOp::OpAngle:
3934 int page = SMESHGUI_MeasureDlg::MinDistance;
3935 if ( theCommandID == SMESHOp::OpBoundingBox )
3936 page = SMESHGUI_MeasureDlg::BoundingBox;
3937 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3938 page = SMESHGUI_MeasureDlg::Length;
3939 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3940 page = SMESHGUI_MeasureDlg::Area;
3941 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3942 page = SMESHGUI_MeasureDlg::Volume;
3943 else if ( theCommandID == SMESHOp::OpAngle )
3944 page = SMESHGUI_MeasureDlg::Angle;
3946 EmitSignalDeactivateDialog();
3947 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3951 case SMESHOp::OpSortChild:
3954 case SMESHOp::OpBreakLink:
3955 ::breakShaperLink();
3960 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3961 //updateObjBrowser();
3965 //=============================================================================
3969 //=============================================================================
3970 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3975 //=============================================================================
3979 //=============================================================================
3980 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3985 //=============================================================================
3989 //=============================================================================
3990 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3995 //=============================================================================
3996 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3997 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3999 //=============================================================================
4000 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4001 SUIT_ViewWindow* wnd )
4003 if(theIO->hasEntry()){
4004 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4005 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4009 //=======================================================================
4010 // function : createSMESHAction
4012 //=======================================================================
4013 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4014 const int key, const bool toggle, const QString& shortcutAction )
4017 QWidget* parent = application()->desktop();
4018 SUIT_ResourceMgr* resMgr = resourceMgr();
4020 if ( !icon_id.isEmpty() )
4021 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4023 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4024 if ( !pix.isNull() )
4025 icon = QIcon( pix );
4027 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4028 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4029 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4031 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4032 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4035 //=======================================================================
4036 // function : createPopupItem
4038 //=======================================================================
4039 void SMESHGUI::createPopupItem( const int id,
4040 const QString& clients,
4041 const QString& types,
4042 const QString& theRule,
4045 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4046 popupMgr()->insert( action( id ), pId, 0 );
4048 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4049 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4050 QString rule = "(%1) and (%2) and (%3)";
4051 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4052 if( clients.isEmpty() )
4053 rule = rule.arg( QString( "true" ) );
4055 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4056 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4059 bool cont = myRules.contains( id );
4061 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4063 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4064 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4067 //=======================================================================
4068 // function : initialize
4070 //=======================================================================
4071 void SMESHGUI::initialize( CAM_Application* app )
4073 SalomeApp_Module::initialize( app );
4075 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4077 /* Automatic Update flag */
4078 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4080 // ----- create actions --------------
4082 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4083 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4084 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4085 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4087 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4089 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4090 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4091 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4092 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4094 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4096 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4098 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4099 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4100 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4101 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4103 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4105 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4106 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4107 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4108 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4109 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4111 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4113 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4114 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4115 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4116 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4117 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4118 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4119 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4120 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4121 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4122 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4123 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4124 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4125 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4126 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4127 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4128 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4129 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4130 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4131 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4132 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4133 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4134 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4135 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4136 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4137 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4138 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4139 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4140 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4141 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4142 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4143 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4144 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4145 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4146 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4147 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4149 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4150 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4151 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4152 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4153 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4154 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4155 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4156 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4157 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4158 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4159 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4160 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4161 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4162 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4163 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4164 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4165 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4166 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4167 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4168 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4169 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4170 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4171 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4172 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4173 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4174 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4175 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4176 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4177 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4179 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4180 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4181 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4182 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4183 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4184 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4185 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4186 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4187 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4188 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4189 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4190 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4191 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4192 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4193 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4194 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4195 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4196 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4197 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4198 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4199 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4200 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4201 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4202 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4203 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4204 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4206 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4207 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4208 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4209 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4211 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4212 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4214 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4215 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4216 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4217 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4218 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4219 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4220 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4221 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4222 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4223 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4224 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4225 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4226 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4227 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4228 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4229 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4230 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4231 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4232 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4233 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4234 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4235 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4236 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4237 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4238 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4240 createSMESHAction( SMESHOp::OpReset, "RESET" );
4241 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4242 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4243 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4244 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4245 #ifndef DISABLE_PLOT2DVIEWER
4246 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4248 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4249 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4250 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4251 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4252 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4253 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4254 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4255 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4256 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4257 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4258 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4259 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4260 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4262 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4263 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4265 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4266 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4267 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4268 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4269 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4270 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4271 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4272 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4273 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4275 // Adaptation - begin
4276 #ifndef DISABLE_MG_ADAPT
4277 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4279 createSMESHAction( SMESHOp::OpHomardAdapt, "HOMARD_ADAPT", "ICON_HOMARD_ADAPT" );
4282 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4283 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4284 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4285 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4286 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4287 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4289 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4290 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4291 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4293 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4295 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4297 QList<int> aCtrlActions;
4298 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4299 << SMESHOp::OpNodeConnectivityNb // node controls
4300 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4301 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4302 << SMESHOp::OpDeflection2D
4303 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4304 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4305 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4306 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4307 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4308 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4309 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4310 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4311 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4312 aCtrlGroup->setExclusive( true );
4313 for( int i = 0; i < aCtrlActions.size(); i++ )
4314 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4316 // ----- create menu --------------
4317 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4318 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4319 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4320 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4321 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4322 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4323 #ifndef DISABLE_MG_ADAPT
4324 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4326 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4327 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4329 createMenu( separator(), fileId );
4331 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4332 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4333 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4334 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4335 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4336 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4337 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4338 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4339 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4340 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4341 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4342 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4343 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4345 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4346 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4347 createMenu( SMESHOp::OpImportMED, importId, -1 );
4348 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4350 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4352 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4353 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4354 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4355 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4356 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4358 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4360 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4361 createMenu( separator(), fileId, 10 );
4363 createMenu( SMESHOp::OpDelete, editId, -1 );
4365 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4367 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4368 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4369 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4370 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4371 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4372 createMenu( separator(), meshId, -1 );
4373 createMenu( SMESHOp::OpCompute, meshId, -1 );
4374 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4375 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4376 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4377 createMenu( separator(), meshId, -1 );
4378 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4379 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4380 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4381 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4382 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4383 createMenu( separator(), meshId, -1 );
4384 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4385 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4386 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4387 createMenu( separator(), meshId, -1 );
4388 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4389 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4390 createMenu( separator(), meshId, -1 );
4391 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4392 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4393 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4394 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4395 createMenu( separator(), meshId, -1 );
4397 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4398 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4399 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4400 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4401 createMenu( SMESHOp::OpLength, edgeId, -1 );
4402 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4403 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4404 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4405 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4406 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4407 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4408 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4409 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4410 createMenu( SMESHOp::OpArea, faceId, -1 );
4411 createMenu( SMESHOp::OpTaper, faceId, -1 );
4412 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4413 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4414 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4415 createMenu( SMESHOp::OpSkew, faceId, -1 );
4416 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4417 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4418 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4419 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4420 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4421 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4422 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4423 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4424 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4425 createMenu( separator(), ctrlId, -1 );
4426 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4427 createMenu( separator(), ctrlId, -1 );
4428 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4430 createMenu( SMESHOp::OpNode, addId, -1 );
4431 createMenu( SMESHOp::OpElem0D, addId, -1 );
4432 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4433 createMenu( SMESHOp::OpBall, addId, -1 );
4434 createMenu( SMESHOp::OpEdge, addId, -1 );
4435 createMenu( SMESHOp::OpTriangle, addId, -1 );
4436 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4437 createMenu( SMESHOp::OpPolygon, addId, -1 );
4438 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4439 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4440 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4441 createMenu( SMESHOp::OpPyramid, addId, -1 );
4442 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4443 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4444 createMenu( separator(), addId, -1 );
4445 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4446 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4447 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4448 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4449 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4450 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4451 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4452 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4453 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4454 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4455 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4456 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4458 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4459 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4460 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4461 createMenu( separator(), removeId, -1 );
4462 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4463 createMenu( separator(), removeId, -1 );
4464 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4466 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4467 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4469 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4470 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4471 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4472 createMenu( SMESHOp::OpRotation, transfId, -1 );
4473 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4474 createMenu( SMESHOp::OpScale, transfId, -1 );
4475 createMenu( SMESHOp::OpOffset, transfId, -1 );
4476 createMenu( SMESHOp::OpSewing, transfId, -1 );
4477 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4479 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4480 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4481 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4482 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4483 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4484 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4485 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4486 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4487 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4488 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4489 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4490 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4491 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4492 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4493 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4494 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4496 // Adaptation - begin
4497 #ifndef DISABLE_MG_ADAPT
4498 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4500 createMenu( SMESHOp::OpHomardAdapt, adaptId, -1 );
4503 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4504 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4505 createMenu( SMESHOp::OpAngle, measureId, -1 );
4506 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4507 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4508 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4509 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4511 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4512 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4513 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4514 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4516 // ----- create toolbars --------------
4517 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4518 createTool( SMESHOp::OpCreateMesh, meshTb );
4519 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4520 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4521 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4522 createTool( SMESHOp::OpCopyMesh, meshTb );
4523 createTool( separator(), meshTb );
4524 createTool( SMESHOp::OpCompute, meshTb );
4525 createTool( SMESHOp::OpPreCompute, meshTb );
4526 createTool( SMESHOp::OpEvaluate, meshTb );
4527 createTool( SMESHOp::OpMeshOrder, meshTb );
4529 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4530 createTool( SMESHOp::OpMeshInformation, infoTb );
4531 //createTool( SMESHOp::OpStdInfo, meshTb );
4532 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4533 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4535 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4536 createTool( SMESHOp::OpCreateGroup, groupTb );
4537 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4538 createTool( SMESHOp::OpConstructGroup, groupTb );
4539 createTool( SMESHOp::OpEditGroup, groupTb );
4541 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4542 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4543 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4544 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4546 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4547 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4548 createTool( SMESHOp::OpLength, ctrl1dTb );
4549 createTool( SMESHOp::OpConnection, ctrl1dTb );
4550 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4552 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4553 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4554 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4555 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4556 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4557 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4558 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4559 createTool( SMESHOp::OpArea, ctrl2dTb );
4560 createTool( SMESHOp::OpTaper, ctrl2dTb );
4561 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4562 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4563 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4564 createTool( SMESHOp::OpSkew, ctrl2dTb );
4565 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4566 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4567 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4569 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4570 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4571 createTool( SMESHOp::OpVolume, ctrl3dTb );
4572 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4573 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4574 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4575 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4577 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4578 createTool( SMESHOp::OpNode, addElemTb );
4579 createTool( SMESHOp::OpElem0D, addElemTb );
4580 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4581 createTool( SMESHOp::OpBall, addElemTb );
4582 createTool( SMESHOp::OpEdge, addElemTb );
4583 createTool( SMESHOp::OpTriangle, addElemTb );
4584 createTool( SMESHOp::OpQuadrangle, addElemTb );
4585 createTool( SMESHOp::OpPolygon, addElemTb );
4586 createTool( SMESHOp::OpTetrahedron, addElemTb );
4587 createTool( SMESHOp::OpHexahedron, addElemTb );
4588 createTool( SMESHOp::OpPentahedron, addElemTb );
4589 createTool( SMESHOp::OpPyramid, addElemTb );
4590 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4591 createTool( SMESHOp::OpPolyhedron, addElemTb );
4593 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4594 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4595 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4596 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4597 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4598 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4599 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4600 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4601 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4602 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4603 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4604 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4605 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4607 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4608 createTool( SMESHOp::OpRemoveNodes, remTb );
4609 createTool( SMESHOp::OpRemoveElements, remTb );
4610 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4611 createTool( SMESHOp::OpClearMesh, remTb );
4613 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4614 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4615 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4617 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4618 createTool( SMESHOp::OpMergeNodes, transformTb );
4619 createTool( SMESHOp::OpMergeElements, transformTb );
4620 createTool( SMESHOp::OpTranslation, transformTb );
4621 createTool( SMESHOp::OpRotation, transformTb );
4622 createTool( SMESHOp::OpSymmetry, transformTb );
4623 createTool( SMESHOp::OpScale, transformTb );
4624 createTool( SMESHOp::OpOffset, transformTb );
4625 createTool( SMESHOp::OpSewing, transformTb );
4626 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4628 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4629 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4630 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4631 createTool( SMESHOp::OpExtrusion, modifyTb );
4632 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4633 createTool( SMESHOp::OpRevolution, modifyTb );
4634 createTool( SMESHOp::OpOrientation, modifyTb );
4635 createTool( SMESHOp::OpReorientFaces, modifyTb );
4636 createTool( SMESHOp::OpMoveNode, modifyTb );
4637 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4638 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4639 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4640 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4641 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4642 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4643 createTool( SMESHOp::OpSmoothing, modifyTb );
4644 createTool( SMESHOp::OpPatternMapping, modifyTb );
4646 // Adaptation - begin
4647 #ifndef DISABLE_MG_ADAPT
4648 int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
4649 createTool( SMESHOp::OpMGAdapt, adaptTb );
4651 createTool( SMESHOp::OpHomardAdapt, adaptTb );
4654 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4655 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4657 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4658 createTool( SMESHOp::OpUpdate, dispModeTb );
4660 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4661 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4665 OB = "'ObjectBrowser'",
4666 View = "'" + SVTK_Viewer::Type() + "'",
4668 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4669 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4670 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4671 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4672 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4673 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4674 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4675 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4676 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4677 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4678 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4679 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4681 mesh_part = mesh + " " + subMesh + " " + group,
4682 mesh_group = mesh + " " + group,
4683 mesh_submesh = mesh + " " + subMesh,
4684 hyp_alg = hypo + " " + algo;
4686 // popup for object browser
4688 isInvisible("not( isVisible )"),
4689 isEmpty("numberOfNodes = 0"),
4690 isNotEmpty("numberOfNodes <> 0"),
4692 // has nodes, edges, etc in VISIBLE! actor
4693 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4694 hasElems("(count( elemTypes ) > 0)"),
4695 hasDifferentElems("(count( elemTypes ) > 1)"),
4696 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4697 hasBalls("({'BallElem'} in elemTypes)"),
4698 hasElems0d("({'Elem0d'} in elemTypes)"),
4699 hasEdges("({'Edge'} in elemTypes)"),
4700 hasFaces("({'Face'} in elemTypes)"),
4701 hasVolumes("({'Volume'} in elemTypes)"),
4702 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4704 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4705 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4706 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4707 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4708 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4709 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4711 popupMgr()->insert( separator(), -1, 0 );
4712 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4713 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4714 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4715 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4716 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4717 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4718 popupMgr()->insert( separator(), -1, 0 );
4719 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4720 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4721 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4722 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4723 popupMgr()->insert( separator(), -1, 0 );
4724 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4725 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4726 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4727 popupMgr()->insert( separator(), -1, 0 );
4728 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4729 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4730 popupMgr()->insert( separator(), -1, 0 );
4731 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4732 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4734 // Adaptation - begin
4735 popupMgr()->insert( separator(), -1, 0 );
4736 #ifndef DISABLE_MG_ADAPT
4737 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4739 createPopupItem( SMESHOp::OpHomardAdapt, OB, mesh );
4740 popupMgr()->insert( separator(), -1, 0 );
4743 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4744 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4745 QString only_one_2D = only_one_non_empty + " && dim>1";
4747 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4748 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4749 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4750 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4751 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4753 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4755 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4756 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4758 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4759 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4760 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4761 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4763 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4765 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4766 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4767 popupMgr()->insert( separator(), -1, 0 );
4769 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4770 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4771 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4774 createPopupItem( SMESHOp::OpEditGroup, View, group );
4775 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4776 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4778 popupMgr()->insert( separator(), -1, 0 );
4779 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4780 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4781 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4782 popupMgr()->insert( separator(), -1, 0 );
4784 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4785 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4786 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4787 popupMgr()->insert( separator(), -1, 0 );
4789 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4790 QString aType = QString( "%1type in {%2}" ).arg( lc );
4791 aType = aType.arg( mesh_part );
4792 QString aMeshInVTK = aClient + "&&" + aType;
4794 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4795 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4796 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4798 //-------------------------------------------------
4800 //-------------------------------------------------
4801 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4803 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4805 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4807 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4808 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4809 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4811 popupMgr()->insert( separator(), -1, -1 );
4813 //-------------------------------------------------
4815 //-------------------------------------------------
4816 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4818 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4819 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4820 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4822 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4823 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4824 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4826 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4827 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4828 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4830 popupMgr()->insert( separator(), anId, -1 );
4832 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4833 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4834 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4836 //-------------------------------------------------
4838 //-------------------------------------------------
4839 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4841 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4843 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4844 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4845 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4847 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4848 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4849 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4851 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4853 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4855 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4856 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4857 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4859 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4860 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4861 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4863 popupMgr()->insert( separator(), anId, -1 );
4865 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4866 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4868 popupMgr()->insert( separator(), anId, -1 );
4870 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4871 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4874 //-------------------------------------------------
4875 // Representation of the 2D Quadratic elements
4876 //-------------------------------------------------
4877 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4878 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4879 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4880 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4882 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4883 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4884 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4886 //-------------------------------------------------
4887 // Orientation of faces
4888 //-------------------------------------------------
4889 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4890 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4891 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4893 //-------------------------------------------------
4895 //-------------------------------------------------
4896 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4897 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4899 //-------------------------------------------------
4901 //-------------------------------------------------
4902 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4903 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4905 //-------------------------------------------------
4907 //-------------------------------------------------
4909 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4910 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4911 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4912 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4914 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4916 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4917 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4919 popupMgr()->insert( separator(), anId, -1 );
4921 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4923 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4924 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4925 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4927 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4928 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4929 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4931 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4932 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4933 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4935 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4937 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4938 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4939 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4941 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4942 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4943 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4945 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4946 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4947 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4948 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4949 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4950 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4952 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4954 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4955 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4956 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4958 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4959 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4960 QtxPopupMgr::VisibleRule );
4961 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4963 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4964 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4965 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4967 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4968 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4969 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4971 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4972 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4973 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4975 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4976 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4977 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4979 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4980 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4983 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4984 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4985 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4987 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4988 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4989 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4991 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4992 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4993 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4995 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4996 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4997 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4999 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5000 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5001 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5003 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5004 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5005 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5007 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5008 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5009 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5011 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5012 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5013 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5015 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5017 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5018 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5019 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5021 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5022 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5023 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5025 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5026 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5027 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5029 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5030 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5031 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5033 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5034 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5035 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5037 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5038 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5039 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5041 popupMgr()->insert( separator(), anId, -1 );
5043 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5044 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5045 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5046 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5047 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5049 popupMgr()->insert( separator(), anId, -1 );
5051 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5053 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5054 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5056 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5057 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5058 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5060 #ifndef DISABLE_PLOT2DVIEWER
5061 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5062 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5065 //-------------------------------------------------
5067 //-------------------------------------------------
5068 popupMgr()->insert( separator(), -1, -1 );
5069 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5070 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5071 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5072 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5074 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5075 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5077 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5078 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5080 popupMgr()->insert( separator(), -1, -1 );
5082 //-------------------------------------------------
5084 //-------------------------------------------------
5085 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5086 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5088 popupMgr()->insert( separator(), -1, -1 );
5090 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5091 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5092 popupMgr()->insert( separator(), -1, -1 );
5094 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5095 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5097 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5098 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5100 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5101 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5104 //================================================================================
5106 * \brief Return true if SMESH or GEOM objects are selected.
5107 * Is called form LightApp_Module::activateModule() which clear selection if
5108 * not isSelectionCompatible()
5110 //================================================================================
5112 bool SMESHGUI::isSelectionCompatible()
5114 bool isCompatible = true;
5115 SALOME_ListIO selected;
5116 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5117 Sel->selectedObjects( selected );
5119 SALOME_ListIteratorOfListIO It( selected );
5120 for ( ; isCompatible && It.More(); It.Next())
5122 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5123 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5124 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5126 return isCompatible;
5130 bool SMESHGUI::reusableOperation( const int id )
5132 // compute, evaluate and precompute are not reusable operations
5133 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5138 QString wrap(const QString& text, const QString& tag)
5139 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5142 bool SMESHGUI::activateModule( SUIT_Study* study )
5144 bool res = SalomeApp_Module::activateModule( study );
5146 setMenuShown( true );
5147 setToolShown( true );
5149 // Fill in Help Panel
5150 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5151 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5153 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5156 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5157 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5158 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5159 lab = lab + tr("INFO_REFINE") + ":";
5160 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5161 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5162 lab = lab + wrap(items.join(""), "ul");
5165 app->infoPanel()->addLabel(lab, gb);
5167 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5168 items << wrap("UNV", "li")
5169 << wrap("MED", "li")
5170 << wrap("STL", "li")
5171 << wrap("CGNS", "li")
5172 << wrap("GMF", "li");
5173 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5176 app->infoPanel()->addLabel(lab, gb);
5178 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5179 lab = tr("INFO_DISPLAY") + "<br/>";
5180 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5181 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5182 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5183 << wrap("...", "li");
5184 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5186 lab = lab + tr("INFO_CLIPPING");
5188 app->infoPanel()->addLabel(lab, gb);
5191 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5192 PyGILState_STATE gstate = PyGILState_Ensure();
5193 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5194 if ( !pluginsmanager ) {
5198 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5203 PyGILState_Release(gstate);
5204 // end of SMESH plugins loading
5206 // Reset actions accelerator keys
5207 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5209 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5210 GetSMESHGen()->UpdateStudy();
5212 // get all view currently opened in the study and connect their signals to
5213 // the corresponding slots of the class.
5214 SUIT_Desktop* aDesk = study->application()->desktop();
5216 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5217 SUIT_ViewWindow* wnd;
5218 foreach ( wnd, wndList )
5222 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5223 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5229 Py_XDECREF(pluginsmanager);
5233 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5235 setMenuShown( false );
5236 setToolShown( false );
5238 EmitSignalCloseAllDialogs();
5240 // Unset actions accelerator keys
5241 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5243 return SalomeApp_Module::deactivateModule( study );
5246 void SMESHGUI::studyClosed( SUIT_Study* s )
5250 SMESH::RemoveVisuData();
5251 SalomeApp_Module::studyClosed( s );
5254 void SMESHGUI::OnGUIEvent()
5256 const QObject* obj = sender();
5257 if ( !obj || !obj->inherits( "QAction" ) )
5259 int id = actionId((QAction*)obj);
5264 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5266 if ( CORBA::is_nil( myComponentSMESH ) )
5268 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5269 return aGUI.myComponentSMESH;
5271 return myComponentSMESH;
5274 QString SMESHGUI::engineIOR() const
5276 CORBA::ORB_var anORB = getApp()->orb();
5277 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5278 return QString( anIOR.in() );
5281 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5283 SalomeApp_Module::contextMenuPopup( client, menu, title );
5285 selectionMgr()->selectedObjects( lst );
5286 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5287 Handle(SALOME_InteractiveObject) io = lst.First();
5288 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5289 _PTR(Study) study = appStudy->studyDS();
5290 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5292 QString aName = SMESH::fromUtf8( obj->GetName());
5293 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5294 aName.remove(( aName.length() - 1 ), 1 );
5300 LightApp_Selection* SMESHGUI::createSelection() const
5302 return new SMESHGUI_Selection();
5305 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5307 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5308 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5309 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5310 #ifndef DISABLE_PYCONSOLE
5311 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5315 void SMESHGUI::viewManagers( QStringList& list ) const
5317 list.append( SVTK_Viewer::Type() );
5320 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5322 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5323 SMESH::UpdateSelectionProp( this );
5325 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5326 for(int i = 0; i < aViews.count() ; i++){
5327 SUIT_ViewWindow *sf = aViews[i];
5330 EmitSignalActivatedViewManager();
5334 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5336 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5337 myClippingPlaneInfoMap.erase( theViewManager );
5340 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5342 theActor->AddObserver( SMESH::DeleteActorEvent,
5343 myEventCallbackCommand.GetPointer(),
5347 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5348 unsigned long theEvent,
5349 void* theClientData,
5350 void* /*theCallData*/ )
5352 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5353 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5354 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5355 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5356 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5357 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5358 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5359 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5360 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5361 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5362 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5363 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5364 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5365 if( anActor == *anIter3 ) {
5366 anActorList.erase( anIter3 );
5377 void SMESHGUI::createPreferences()
5379 // General tab ------------------------------------------------------------------------
5380 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5382 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5383 setPreferenceProperty( autoUpdate, "columns", 2 );
5384 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5385 setPreferenceProperty( lim, "min", 0 );
5386 setPreferenceProperty( lim, "max", 100000000 );
5387 setPreferenceProperty( lim, "step", 1000 );
5388 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5389 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5391 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5392 setPreferenceProperty( dispgroup, "columns", 2 );
5394 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5396 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5398 modes.append( tr("MEN_WIRE") );
5399 modes.append( tr("MEN_SHADE") );
5400 modes.append( tr("MEN_NODES") );
5401 modes.append( tr("MEN_SHRINK") );
5402 QList<QVariant> indices;
5403 indices.append( 0 );
5404 indices.append( 1 );
5405 indices.append( 2 );
5406 indices.append( 3 );
5407 setPreferenceProperty( dispmode, "strings", modes );
5408 setPreferenceProperty( dispmode, "indexes", indices );
5410 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5411 setPreferenceProperty( arcgroup, "columns", 2 );
5412 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5413 QStringList quadraticModes;
5414 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5415 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5417 indices.append( 0 );
5418 indices.append( 1 );
5419 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5420 setPreferenceProperty( quadraticmode, "indexes", indices );
5422 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5423 "SMESH", "max_angle" );
5424 setPreferenceProperty( maxAngle, "min", 1 );
5425 setPreferenceProperty( maxAngle, "max", 90 );
5427 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5428 setPreferenceProperty( qaGroup, "columns", 2 );
5429 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5430 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5431 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5432 setPreferenceProperty( prec, "min", 0 );
5433 setPreferenceProperty( prec, "max", 100 );
5434 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5435 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5436 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5437 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5438 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5441 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5442 setPreferenceProperty( cinc, "min", 0 );
5443 setPreferenceProperty( cinc, "max", 5 );
5446 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5447 setPreferenceProperty( exportgroup, "columns", 2 );
5448 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5449 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5450 addPreference( tr( "PREF_MED_SAVE_NUMS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "med_save_numbers" );
5451 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5452 setPreferenceProperty( zTol, "precision", 10 );
5453 setPreferenceProperty( zTol, "min", 0.0000000001 );
5454 setPreferenceProperty( zTol, "max", 1000000.0 );
5455 setPreferenceProperty( zTol, "step", 1. );
5456 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5458 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5459 setPreferenceProperty( computeGroup, "columns", 2 );
5460 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5462 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5463 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5464 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5466 indices.append( 0 );
5467 indices.append( 1 );
5468 indices.append( 2 );
5469 setPreferenceProperty( notifyMode, "strings", modes );
5470 setPreferenceProperty( notifyMode, "indexes", indices );
5472 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5473 setPreferenceProperty( infoGroup, "columns", 2 );
5474 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5476 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5477 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5479 indices.append( 0 );
5480 indices.append( 1 );
5481 setPreferenceProperty( elemInfo, "strings", modes );
5482 setPreferenceProperty( elemInfo, "indexes", indices );
5483 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5484 setPreferenceProperty( nodesLim, "min", 0 );
5485 setPreferenceProperty( nodesLim, "max", 10000000 );
5486 setPreferenceProperty( nodesLim, "step", 10000 );
5487 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5488 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5489 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5490 setPreferenceProperty( ctrlLim, "min", 0 );
5491 setPreferenceProperty( ctrlLim, "max", 10000000 );
5492 setPreferenceProperty( ctrlLim, "step", 1000 );
5493 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5494 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5495 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5496 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5497 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5499 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5500 setPreferenceProperty( segGroup, "columns", 2 );
5501 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5502 "SMESH", "segmentation" );
5503 setPreferenceProperty( segLen, "min", 1 );
5504 setPreferenceProperty( segLen, "max", 10000000 );
5505 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5506 "SMESH", "nb_segments_per_edge" );
5507 setPreferenceProperty( nbSeg, "min", 1 );
5508 setPreferenceProperty( nbSeg, "max", 10000000 );
5509 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5511 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5512 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5513 "SMESH", "forget_mesh_on_hyp_modif" );
5516 // Quantities with individual precision settings
5517 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5518 setPreferenceProperty( precGroup, "columns", 2 );
5520 const int nbQuantities = 6;
5521 int precs[nbQuantities], ii = 0;
5522 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5523 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5524 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5525 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5526 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5527 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5528 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5529 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5530 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5531 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5532 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5533 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5535 // Set property for precision value for spinboxes
5536 for ( ii = 0; ii < nbQuantities; ii++ ){
5537 setPreferenceProperty( precs[ii], "min", -14 );
5538 setPreferenceProperty( precs[ii], "max", 14 );
5539 setPreferenceProperty( precs[ii], "precision", 2 );
5542 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5543 setPreferenceProperty( previewGroup, "columns", 2 );
5544 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5545 setPreferenceProperty( chunkSize, "min", 1 );
5546 setPreferenceProperty( chunkSize, "max", 1000 );
5547 setPreferenceProperty( chunkSize, "step", 50 );
5549 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5550 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5552 // Mesh tab ------------------------------------------------------------------------
5553 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5554 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5555 setPreferenceProperty( nodeGroup, "columns", 3 );
5557 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5559 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5561 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5562 QList<QVariant> aMarkerTypeIndicesList;
5563 QList<QVariant> aMarkerTypeIconsList;
5564 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5565 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5566 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5567 aMarkerTypeIndicesList << i;
5568 aMarkerTypeIconsList << pixmap;
5570 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5571 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5573 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5575 QList<QVariant> aMarkerScaleIndicesList;
5576 QStringList aMarkerScaleValuesList;
5577 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5578 aMarkerScaleIndicesList << i;
5579 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5580 aMarkerScaleValuesList << QString::number( i );
5582 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5583 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5585 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5586 //setPreferenceProperty( elemGroup, "columns", 2 );
5588 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5589 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5590 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5591 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5592 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5593 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5594 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5595 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5596 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5599 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5600 setPreferenceProperty( grpGroup, "columns", 2 );
5602 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5603 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5605 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5606 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5607 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5608 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5609 int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5610 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5611 int ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5612 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5613 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5614 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5615 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5616 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5617 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5618 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5620 setPreferenceProperty( size0d, "min", 1 );
5621 setPreferenceProperty( size0d, "max", 10 );
5623 // setPreferenceProperty( ballSize, "min", 1 );
5624 // setPreferenceProperty( ballSize, "max", 10 );
5626 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5627 setPreferenceProperty( ballDiameter, "max", 1e9 );
5628 setPreferenceProperty( ballDiameter, "step", 0.1 );
5630 setPreferenceProperty( ballScale, "min", 1e-2 );
5631 setPreferenceProperty( ballScale, "max", 1e7 );
5632 setPreferenceProperty( ballScale, "step", 0.5 );
5634 setPreferenceProperty( elemW, "min", 1 );
5635 setPreferenceProperty( elemW, "max", 5 );
5637 setPreferenceProperty( outW, "min", 1 );
5638 setPreferenceProperty( outW, "max", 5 );
5640 setPreferenceProperty( shrink, "min", 0 );
5641 setPreferenceProperty( shrink, "max", 100 );
5643 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5644 setPreferenceProperty( numGroup, "columns", 2 );
5646 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5647 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5649 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5650 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5652 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5653 setPreferenceProperty( orientGroup, "columns", 1 );
5655 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5656 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5658 setPreferenceProperty( orientScale, "min", 0.05 );
5659 setPreferenceProperty( orientScale, "max", 0.5 );
5660 setPreferenceProperty( orientScale, "step", 0.05 );
5662 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5664 // Selection tab ------------------------------------------------------------------------
5665 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5667 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5668 setPreferenceProperty( selGroup, "columns", 2 );
5670 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5671 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5673 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5674 setPreferenceProperty( preGroup, "columns", 2 );
5676 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5678 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5679 setPreferenceProperty( precSelGroup, "columns", 2 );
5681 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5682 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5683 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5685 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5686 setPreferenceProperty( sinc, "min", 0 );
5687 setPreferenceProperty( sinc, "max", 5 );
5689 // Scalar Bar tab ------------------------------------------------------------------------
5690 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5691 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5692 setPreferenceProperty( fontGr, "columns", 2 );
5694 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5695 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5697 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5698 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5700 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5701 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5703 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5704 setPreferenceProperty( numcol, "min", 2 );
5705 setPreferenceProperty( numcol, "max", 256 );
5707 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5708 setPreferenceProperty( numlab, "min", 2 );
5709 setPreferenceProperty( numlab, "max", 65 );
5711 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5712 setPreferenceProperty( orientGr, "columns", 2 );
5713 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5714 QStringList orients;
5715 orients.append( tr( "SMESH_VERTICAL" ) );
5716 orients.append( tr( "SMESH_HORIZONTAL" ) );
5717 indices.clear(); indices.append( 0 ); indices.append( 1 );
5718 setPreferenceProperty( orient, "strings", orients );
5719 setPreferenceProperty( orient, "indexes", indices );
5721 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5722 setPreferenceProperty( posVSizeGr, "columns", 2 );
5723 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5724 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5725 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5726 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5727 setPreferenceProperty( xv, "step", 0.1 );
5728 setPreferenceProperty( xv, "min", 0.0 );
5729 setPreferenceProperty( xv, "max", 1.0 );
5730 setPreferenceProperty( yv, "step", 0.1 );
5731 setPreferenceProperty( yv, "min", 0.0 );
5732 setPreferenceProperty( yv, "max", 1.0 );
5733 setPreferenceProperty( wv, "step", 0.1 );
5734 setPreferenceProperty( wv, "min", 0.0 );
5735 setPreferenceProperty( wv, "max", 1.0 );
5736 setPreferenceProperty( hv, "min", 0.0 );
5737 setPreferenceProperty( hv, "max", 1.0 );
5738 setPreferenceProperty( hv, "step", 0.1 );
5740 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5741 setPreferenceProperty( posHSizeGr, "columns", 2 );
5742 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5743 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5744 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5745 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5746 setPreferenceProperty( xv, "min", 0.0 );
5747 setPreferenceProperty( xv, "max", 1.0 );
5748 setPreferenceProperty( xv, "step", 0.1 );
5749 setPreferenceProperty( xh, "min", 0.0 );
5750 setPreferenceProperty( xh, "max", 1.0 );
5751 setPreferenceProperty( xh, "step", 0.1 );
5752 setPreferenceProperty( yh, "min", 0.0 );
5753 setPreferenceProperty( yh, "max", 1.0 );
5754 setPreferenceProperty( yh, "step", 0.1 );
5755 setPreferenceProperty( wh, "min", 0.0 );
5756 setPreferenceProperty( wh, "max", 1.0 );
5757 setPreferenceProperty( wh, "step", 0.1 );
5758 setPreferenceProperty( hh, "min", 0.0 );
5759 setPreferenceProperty( hh, "max", 1.0 );
5760 setPreferenceProperty( hh, "step", 0.1 );
5762 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5763 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5764 setPreferenceProperty( distributionGr, "columns", 3 );
5766 types.append( tr( "SMESH_MONOCOLOR" ) );
5767 types.append( tr( "SMESH_MULTICOLOR" ) );
5768 indices.clear(); indices.append( 0 ); indices.append( 1 );
5769 setPreferenceProperty( coloringType, "strings", types );
5770 setPreferenceProperty( coloringType, "indexes", indices );
5771 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5773 // Adaptation - begin
5774 #ifndef DISABLE_MG_ADAPT
5775 // Adaptation tab ------------------------------------------------------------------------
5776 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5779 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5780 setPreferenceProperty( bloc, "columns", 1 );
5781 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5782 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5783 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5784 QStringList aListOfSizeMap;
5785 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5786 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5787 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5788 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5789 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5790 QStringList aListOfTimeStep;
5791 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5792 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5793 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5794 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5799 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5801 if ( sect=="SMESH" ) {
5802 double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5803 double aTol = 1.00000009999999;
5804 std::string aWarning;
5805 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5807 if ( name == "selection_object_color" ||
5808 name == "selection_element_color" ||
5809 name == "highlight_color" ||
5810 name == "selection_precision_node" ||
5811 name == "selection_precision_element" ||
5812 name == "selection_precision_object" ||
5813 name == "selection_increment")
5815 SMESH::UpdateSelectionProp( this );
5817 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5819 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5820 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5821 if ( sbX1+sbW > aTol ) {
5822 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5825 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5826 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5829 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5831 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5832 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5833 if ( sbY1 + sbH > aTol ) {
5834 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5835 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5836 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5839 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5841 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5842 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5843 if ( sbX1 + sbW > aTol ) {
5844 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5847 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5848 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5851 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5853 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5854 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5855 if ( sbY1 + sbH > aTol ) {
5856 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5859 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5860 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5863 else if ( name == "segmentation" )
5865 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5866 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5868 else if ( name == "nb_segments_per_edge" )
5870 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5871 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5873 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5875 QString val = aResourceMgr->stringValue( "SMESH", name );
5876 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5878 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5880 SMESH::UpdateFontProp( this );
5882 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5884 SMESH::UpdateFontProp( this );
5887 if ( aWarning.size() != 0 ) {
5888 aWarning += "The default values are applied instead.";
5889 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5890 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5891 QObject::tr(aWarning.c_str()));
5896 //================================================================================
5898 * \brief Update something in accordance with update flags
5899 * \param theFlags - update flags
5901 * Update viewer or/and object browser etc. in accordance with update flags ( see
5902 * LightApp_UpdateFlags enumeration ).
5904 //================================================================================
5905 void SMESHGUI::update( const int flags )
5907 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5908 SMESH::UpdateView();
5910 SalomeApp_Module::update( flags );
5913 //================================================================================
5915 * \brief Set default selection mode
5917 * SLOT called when operation committed. Sets default selection mode
5919 //================================================================================
5920 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5922 SVTK_ViewWindow* vtkWnd =
5923 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5925 vtkWnd->SetSelectionMode( ActorSelection );
5928 //================================================================================
5930 * \brief Set default selection mode
5932 * SLOT called when operation aborted. Sets default selection mode
5934 //================================================================================
5935 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5937 SVTK_ViewWindow* vtkWnd =
5938 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5940 vtkWnd->SetSelectionMode( ActorSelection );
5943 //================================================================================
5945 * \brief Creates operation with given identifier
5946 * \param id - identifier of operation to be started
5947 * \return Pointer on created operation or NULL if operation is not created
5949 * Virtual method redefined from the base class creates operation with given id.
5950 * It is called called automatically from startOperation method of base class.
5952 //================================================================================
5953 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5955 LightApp_Operation* op = 0;
5956 // to do : create operation here
5959 case SMESHOp::OpSplitBiQuadratic:
5960 op = new SMESHGUI_SplitBiQuadOp();
5962 case SMESHOp::OpConvertMeshToQuadratic:
5963 op = new SMESHGUI_ConvToQuadOp();
5965 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5966 op = new SMESHGUI_Make2DFrom3DOp();
5968 case SMESHOp::OpReorientFaces:
5969 op = new SMESHGUI_ReorientFacesOp();
5971 case SMESHOp::OpCreateMesh:
5972 op = new SMESHGUI_MeshOp( true, true );
5974 case SMESHOp::OpCreateSubMesh:
5975 op = new SMESHGUI_MeshOp( true, false );
5977 case SMESHOp::OpEditMeshOrSubMesh:
5978 case SMESHOp::OpEditMesh:
5979 case SMESHOp::OpEditSubMesh:
5980 op = new SMESHGUI_MeshOp( false );
5982 case SMESHOp::OpCompute:
5983 case SMESHOp::OpComputeSubMesh:
5984 op = new SMESHGUI_ComputeOp();
5986 case SMESHOp::OpShowErrors:
5987 op = new SMESHGUI_ShowErrorsOp();
5989 case SMESHOp::OpPreCompute:
5990 op = new SMESHGUI_PrecomputeOp();
5992 case SMESHOp::OpEvaluate:
5993 op = new SMESHGUI_EvaluateOp();
5995 case SMESHOp::OpMeshOrder:
5996 op = new SMESHGUI_MeshOrderOp();
5998 case SMESHOp::OpCreateGeometryGroup:
5999 op = new SMESHGUI_GroupOnShapeOp();
6001 case SMESHOp::OpFindElementByPoint:
6002 op = new SMESHGUI_FindElemByPointOp();
6004 case SMESHOp::OpMoveNode: // Make mesh pass through point
6005 op = new SMESHGUI_MakeNodeAtPointOp();
6007 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6008 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6015 op = SalomeApp_Module::createOperation( id );
6019 //================================================================================
6021 * \brief Stops current operations and starts a given one
6022 * \param id - The id of the operation to start
6024 //================================================================================
6026 void SMESHGUI::switchToOperation(int id)
6028 activeStudy()->abortAllOperations();
6029 startOperation( id );
6032 LightApp_Displayer* SMESHGUI::displayer()
6035 myDisplayer = new SMESHGUI_Displayer( getApp() );
6039 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6042 int aTolerance = 64;
6043 int anIterations = 0;
6049 if( anIterations % aPeriod == 0 )
6052 if( aTolerance < 1 )
6056 aHue = (int)( 360.0 * rand() / RAND_MAX );
6059 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6060 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6061 for( ; it != itEnd; ++it )
6063 SALOMEDS::Color anAutoColor = *it;
6064 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6067 aQColor.getHsv( &h, &s, &v );
6068 if( abs( h - aHue ) < aTolerance )
6080 aColor.setHsv( aHue, 255, 255 );
6082 SALOMEDS::Color aSColor;
6083 aSColor.R = aColor.redF();
6084 aSColor.G = aColor.greenF();
6085 aSColor.B = aColor.blueF();
6090 const char* gSeparator = "_"; // character used to separate parameter names
6091 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6092 const char* gPathSep = "|"; // character used to separate paths
6095 * \brief Store visual parameters
6097 * This method is called just before the study document is saved.
6098 * Store visual parameters in AttributeParameter attribute(s)
6100 void SMESHGUI::storeVisualParameters (int savePoint)
6103 Kernel_Utils::Localizer loc;
6105 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6106 if (!appStudy || !appStudy->studyDS())
6108 _PTR(Study) studyDS = appStudy->studyDS();
6110 // componentName is used for encoding of entries when storing them in IParameters
6111 std::string componentName = myComponentSMESH->ComponentDataType();
6112 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6113 //if (!aSComponent) return;
6116 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6117 componentName.c_str(),
6119 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6121 // store custom markers
6122 if( !myMarkerMap.empty() )
6124 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6125 for( ; anIter != myMarkerMap.end(); anIter++ )
6127 int anId = anIter->first;
6128 VTK::MarkerData aMarkerData = anIter->second;
6129 std::string aMarkerFileName = aMarkerData.first;
6130 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6131 if( aMarkerTexture.size() < 3 )
6132 continue; // should contain at least width, height and the first value
6134 QString aPropertyName( "texture" );
6135 aPropertyName += gSeparator;
6136 aPropertyName += QString::number( anId );
6138 QString aPropertyValue = aMarkerFileName.c_str();
6139 aPropertyValue += gPathSep;
6141 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6142 ushort aWidth = *aTextureIter++;
6143 ushort aHeight = *aTextureIter++;
6144 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6145 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6146 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6147 aPropertyValue += QString::number( *aTextureIter );
6149 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6153 // viewers counters are used for storing view_numbers in IParameters
6156 // main cycle to store parameters of displayed objects
6157 QList<SUIT_ViewManager*> lst;
6158 QList<SUIT_ViewManager*>::Iterator it;
6159 getApp()->viewManagers(lst);
6160 for (it = lst.begin(); it != lst.end(); it++)
6162 SUIT_ViewManager* vman = *it;
6163 QString vType = vman->getType();
6165 // saving VTK actors properties
6166 if (vType == SVTK_Viewer::Type())
6168 // store the clipping planes attached to the view manager
6169 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6170 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6171 if( anIter != myClippingPlaneInfoMap.end() )
6172 aClippingPlaneInfoList = anIter->second;
6174 if( !aClippingPlaneInfoList.empty() ) {
6175 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6176 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6178 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6179 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6181 QString aPropertyName( "ClippingPlane" );
6182 aPropertyName += gSeparator;
6183 aPropertyName += QString::number( vtkViewers );
6184 aPropertyName += gSeparator;
6185 aPropertyName += QString::number( anId );
6187 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6188 aPropertyValue += gDigitsSep;
6189 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6190 aPropertyValue += gDigitsSep;
6191 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6192 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6193 aPropertyValue += gDigitsSep;
6194 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6195 aPropertyValue += gDigitsSep;
6196 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6197 aPropertyValue += gDigitsSep;
6198 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6199 aPropertyValue += gDigitsSep;
6200 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6201 aPropertyValue += gDigitsSep;
6202 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6203 aPropertyValue += gDigitsSep;
6204 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6206 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6207 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6208 aPropertyValue += gDigitsSep;
6209 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6210 aPropertyValue += gDigitsSep;
6211 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6212 aPropertyValue += gDigitsSep;
6213 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6216 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6220 QVector<SUIT_ViewWindow*> views = vman->getViews();
6221 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6223 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6225 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6226 vtkActorCollection* allActors = aCopy.GetActors();
6227 allActors->InitTraversal();
6228 while (vtkActor* actor = allActors->GetNextActor())
6230 if (actor->GetVisibility()) // store only visible actors
6232 SMESH_Actor* aSmeshActor = 0;
6233 if (actor->IsA("SMESH_Actor"))
6234 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6235 if (aSmeshActor && aSmeshActor->hasIO())
6237 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6240 // entry is "encoded" = it does NOT contain component address,
6241 // since it is a subject to change on next component loading
6242 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6244 std::string param, vtkParam = vType.toLatin1().data();
6245 vtkParam += gSeparator;
6246 vtkParam += QString::number(vtkViewers).toLatin1().data();
6247 vtkParam += gSeparator;
6250 param = vtkParam + "Visibility";
6251 ip->setParameter(entry, param, "On");
6254 param = vtkParam + "Representation";
6255 ip->setParameter(entry, param, QString::number
6256 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6259 param = vtkParam + "IsShrunk";
6260 ip->setParameter(entry, param, QString::number
6261 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6263 // Displayed entities
6264 unsigned int aMode = aSmeshActor->GetEntityMode();
6265 bool isE = aMode & SMESH_Actor::eEdges;
6266 bool isF = aMode & SMESH_Actor::eFaces;
6267 bool isV = aMode & SMESH_Actor::eVolumes;
6268 bool is0d = aMode & SMESH_Actor::e0DElements;
6269 bool isB = aMode & SMESH_Actor::eBallElem;
6271 QString modeStr ("e");
6272 modeStr += gDigitsSep; modeStr += QString::number(isE);
6273 modeStr += gDigitsSep; modeStr += "f";
6274 modeStr += gDigitsSep; modeStr += QString::number(isF);
6275 modeStr += gDigitsSep; modeStr += "v";
6276 modeStr += gDigitsSep; modeStr += QString::number(isV);
6277 modeStr += gDigitsSep; modeStr += "0d";
6278 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6279 modeStr += gDigitsSep; modeStr += "b";
6280 modeStr += gDigitsSep; modeStr += QString::number(isB);
6282 param = vtkParam + "Entities";
6283 ip->setParameter(entry, param, modeStr.toLatin1().data());
6289 aSmeshActor->GetSufaceColor(r, g, b, delta);
6290 QStringList colorStr;
6291 colorStr << "surface";
6292 colorStr << QString::number(r);
6293 colorStr << QString::number(g);
6294 colorStr << QString::number(b);
6296 colorStr << "backsurface";
6297 colorStr << QString::number(delta);
6299 aSmeshActor->GetVolumeColor(r, g, b, delta);
6300 colorStr << "volume";
6301 colorStr << QString::number(r);
6302 colorStr << QString::number(g);
6303 colorStr << QString::number(b);
6304 colorStr << QString::number(delta);
6306 aSmeshActor->GetEdgeColor(r, g, b);
6308 colorStr << QString::number(r);
6309 colorStr << QString::number(g);
6310 colorStr << QString::number(b);
6312 aSmeshActor->GetNodeColor(r, g, b);
6314 colorStr << QString::number(r);
6315 colorStr << QString::number(g);
6316 colorStr << QString::number(b);
6318 aSmeshActor->GetOutlineColor(r, g, b);
6319 colorStr << "outline";
6320 colorStr << QString::number(r);
6321 colorStr << QString::number(g);
6322 colorStr << QString::number(b);
6324 aSmeshActor->Get0DColor(r, g, b);
6325 colorStr << "elem0d";
6326 colorStr << QString::number(r);
6327 colorStr << QString::number(g);
6328 colorStr << QString::number(b);
6330 aSmeshActor->GetBallColor(r, g, b);
6332 colorStr << QString::number(r);
6333 colorStr << QString::number(g);
6334 colorStr << QString::number(b);
6336 aSmeshActor->GetFacesOrientationColor(r, g, b);
6337 colorStr << "orientation";
6338 colorStr << QString::number(r);
6339 colorStr << QString::number(g);
6340 colorStr << QString::number(b);
6342 param = vtkParam + "Colors";
6343 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6346 QStringList sizeStr;
6348 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6349 sizeStr << "outline";
6350 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6351 sizeStr << "elem0d";
6352 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6354 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6355 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6356 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6357 sizeStr << "shrink";
6358 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6359 sizeStr << "orientation";
6360 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6361 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6363 param = vtkParam + "Sizes";
6364 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6369 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6370 if( aMarkerType == VTK::MT_USER ) {
6371 markerStr += "custom";
6372 markerStr += gDigitsSep;
6373 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6377 markerStr += gDigitsSep;
6378 markerStr += QString::number( (int)aMarkerType );
6379 markerStr += gDigitsSep;
6380 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6383 param = vtkParam + "PointMarker";
6384 ip->setParameter(entry, param, markerStr.toLatin1().data());
6387 param = vtkParam + "Opacity";
6388 ip->setParameter(entry, param,
6389 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6392 param = vtkParam + "ClippingPlane";
6394 if( !aClippingPlaneInfoList.empty() ) {
6395 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6396 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6398 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6399 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6400 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6401 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6402 if( aSmeshActor == *anIter2 ) {
6403 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6404 QString::number( anId ).toLatin1().constData() );
6411 ip->setParameter( entry, param, "Off" );
6412 } // if (io->hasEntry())
6413 } // SMESH_Actor && hasIO
6415 } // while.. actors traversal
6419 } // if (SVTK view model)
6420 } // for (viewManagers)
6423 // data structures for clipping planes processing
6427 bool isOpenGLClipping;
6428 vtkIdType RelativeOrientation;
6431 int AbsoluteOrientation;
6432 double X, Y, Z, Dx, Dy, Dz;
6434 typedef std::list<TPlaneData> TPlaneDataList;
6435 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6437 typedef std::list<vtkActor*> TActorList;
6440 TActorList ActorList;
6441 SUIT_ViewManager* ViewManager;
6443 typedef std::list<TPlaneInfo> TPlaneInfoList;
6444 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6447 * \brief Restore visual parameters
6449 * This method is called after the study document is opened.
6450 * Restore visual parameters from AttributeParameter attribute(s)
6452 void SMESHGUI::restoreVisualParameters (int savePoint)
6455 Kernel_Utils::Localizer loc;
6457 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6458 if (!appStudy || !appStudy->studyDS())
6460 _PTR(Study) studyDS = appStudy->studyDS();
6462 // componentName is used for encoding of entries when storing them in IParameters
6463 std::string componentName = myComponentSMESH->ComponentDataType();
6466 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6467 componentName.c_str(),
6469 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6471 // restore custom markers and map of clipping planes
6472 TPlaneDataMap aPlaneDataMap;
6474 std::vector<std::string> properties = ip->getProperties();
6475 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6477 std::string property = *propIt;
6478 QString aPropertyName( property.c_str() );
6479 QString aPropertyValue( ip->getProperty( property ).c_str() );
6481 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6482 if( aPropertyNameList.isEmpty() )
6485 QString aPropertyType = aPropertyNameList[0];
6486 if( aPropertyType == "texture" )
6488 if( aPropertyNameList.size() != 2 )
6492 int anId = aPropertyNameList[1].toInt( &ok );
6493 if( !ok || anId < 1 )
6496 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6497 if( aPropertyValueList.size() != 2 )
6500 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6501 QString aMarkerTextureString = aPropertyValueList[1];
6502 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6503 if( aMarkerTextureStringList.size() != 3 )
6507 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6512 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6516 VTK::MarkerTexture aMarkerTexture;
6517 aMarkerTexture.push_back( aWidth );
6518 aMarkerTexture.push_back( aHeight );
6520 QString aMarkerTextureData = aMarkerTextureStringList[2];
6521 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6523 QChar aChar = aMarkerTextureData.at( i );
6524 if( aChar.isDigit() )
6525 aMarkerTexture.push_back( aChar.digitValue() );
6528 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6530 else if( aPropertyType == "ClippingPlane" )
6532 if( aPropertyNameList.size() != 3 )
6536 int aViewId = aPropertyNameList[1].toInt( &ok );
6537 if( !ok || aViewId < 0 )
6541 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6542 if( !ok || aClippingPlaneId < 0 )
6545 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6546 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6549 TPlaneData aPlaneData;
6550 aPlaneData.AbsoluteOrientation = false;
6551 aPlaneData.RelativeOrientation = 0;
6552 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6553 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6554 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6556 aPlaneData.Id = aClippingPlaneId;
6559 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6564 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6568 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6571 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6576 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6581 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6586 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6591 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6596 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6601 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6605 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6607 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6612 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6617 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6622 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6627 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6628 aPlaneDataList.push_back( aPlaneData );
6632 TPlaneInfoMap aPlaneInfoMap;
6634 std::vector<std::string> entries = ip->getEntries();
6636 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6638 // entry is a normal entry - it should be "decoded" (setting base address of component)
6639 QString entry (ip->decodeEntry(*entIt).c_str());
6641 // Check that the entry corresponds to a real object in the Study
6642 // as the object may be deleted or modified after the visual state is saved.
6643 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6644 if (!so) continue; //Skip the not existent entry
6646 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6647 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6649 std::vector<std::string>::iterator namesIt = paramNames.begin();
6650 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6652 // actors are stored in a map after displaying of them for
6653 // quicker access in the future: map < viewID to actor >
6654 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6656 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6658 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6659 // '_' is used as separator and should not be used in viewer type or parameter names.
6660 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6661 if (lst.size() != 3)
6664 QString viewerTypStr = lst[0];
6665 QString viewIndexStr = lst[1];
6666 QString paramNameStr = lst[2];
6669 int viewIndex = viewIndexStr.toUInt(&ok);
6670 if (!ok) // bad conversion of view index to integer
6674 if (viewerTypStr == SVTK_Viewer::Type())
6676 SMESH_Actor* aSmeshActor = 0;
6677 if (vtkActors.IsBound(viewIndex))
6678 aSmeshActor = vtkActors.Find(viewIndex);
6680 QList<SUIT_ViewManager*> lst;
6681 getApp()->viewManagers(viewerTypStr, lst);
6683 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6684 SUIT_ViewManager* vman = NULL;
6685 if (viewIndex >= 0 && viewIndex < lst.count())
6686 vman = lst.at(viewIndex);
6688 if (paramNameStr == "Visibility")
6690 if (!aSmeshActor && displayer() && vman)
6692 SUIT_ViewModel* vmodel = vman->getViewModel();
6693 // SVTK view model can be casted to SALOME_View
6694 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6696 // store displayed actor in a temporary map for quicker
6697 // access later when restoring other parameters
6698 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6699 vtkRenderer* Renderer = vtkView->getRenderer();
6700 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6701 vtkActorCollection* theActors = aCopy.GetActors();
6702 theActors->InitTraversal();
6703 bool isFound = false;
6704 vtkActor *ac = theActors->GetNextActor();
6705 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6706 if (ac->IsA("SMESH_Actor")) {
6707 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6708 if (aGeomAc->hasIO()) {
6709 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6710 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6712 vtkActors.Bind(viewIndex, aGeomAc);
6718 } // if (paramNameStr == "Visibility")
6721 // the rest properties "work" with SMESH_Actor
6724 QString val ((*valuesIt).c_str());
6727 if (paramNameStr == "Representation") {
6728 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6731 else if (paramNameStr == "IsShrunk") {
6733 if (!aSmeshActor->IsShrunk())
6734 aSmeshActor->SetShrink();
6737 if (aSmeshActor->IsShrunk())
6738 aSmeshActor->UnShrink();
6741 // Displayed entities
6742 else if (paramNameStr == "Entities") {
6743 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6744 int aEntityMode = SMESH_Actor::eAllEntity;
6745 for ( int i = 0; i < mode.count(); i+=2 ) {
6746 if ( i < mode.count()-1 ) {
6747 QString type = mode[i];
6748 bool val = mode[i+1].toInt();
6749 if ( type == "e" && !val )
6750 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6751 else if ( type == "f" && !val )
6752 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6753 else if ( type == "v" && !val )
6754 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6755 else if ( type == "0d" && !val )
6756 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6757 else if ( type == "b" && !val )
6758 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6761 aSmeshActor->SetEntityMode( aEntityMode );
6764 else if (paramNameStr == "Colors") {
6765 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6772 QColor outlineColor;
6773 QColor orientationColor;
6779 // below lines are required to get default values for delta coefficients
6780 // of backface color for faces and color of reversed volumes
6781 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6782 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6783 for ( int i = 0; i < colors.count(); i++ ) {
6784 QString type = colors[i];
6785 if ( type == "surface" ) {
6786 // face color is set by 3 values r:g:b, where
6787 // - r,g,b - is rgb color components
6788 if ( i+1 >= colors.count() ) break; // format error
6789 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6790 if ( i+2 >= colors.count() ) break; // format error
6791 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6792 if ( i+3 >= colors.count() ) break; // format error
6793 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6794 faceColor.setRgbF( r, g, b );
6797 else if ( type == "backsurface" ) {
6798 // backface color can be defined in several ways
6799 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6800 // - in latest versions, it is set as delta coefficient
6801 bool rgbOk = false, deltaOk;
6802 if ( i+1 >= colors.count() ) break; // format error
6803 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6804 int delta = colors[i+1].toInt( &deltaOk );
6806 if ( i+1 < colors.count() ) // index is shifted to 1
6807 g = colors[i+1].toDouble( &rgbOk );
6808 if ( rgbOk ) i++; // shift index
6809 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6810 b = colors[i+1].toDouble( &rgbOk );
6812 // - as currently there's no way to set directly backsurface color as it was before,
6813 // we ignore old dump where r,g,b triple was set
6814 // - also we check that delta parameter is set properly
6815 if ( !rgbOk && deltaOk )
6818 else if ( type == "volume" ) {
6819 // volume color is set by 4 values r:g:b:delta, where
6820 // - r,g,b - is a normal volume rgb color components
6821 // - delta - is a reversed volume color delta coefficient
6822 if ( i+1 >= colors.count() ) break; // format error
6823 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6824 if ( i+2 >= colors.count() ) break; // format error
6825 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6826 if ( i+3 >= colors.count() ) break; // format error
6827 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6828 if ( i+4 >= colors.count() ) break; // format error
6829 int delta = colors[i+4].toInt( &bOk );
6830 if ( !bOk ) break; // format error
6831 volumeColor.setRgbF( r, g, b );
6835 else if ( type == "edge" ) {
6836 // edge color is set by 3 values r:g:b, where
6837 // - r,g,b - is rgb color components
6838 if ( i+1 >= colors.count() ) break; // format error
6839 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6840 if ( i+2 >= colors.count() ) break; // format error
6841 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6842 if ( i+3 >= colors.count() ) break; // format error
6843 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6844 edgeColor.setRgbF( r, g, b );
6847 else if ( type == "node" ) {
6848 // node color is set by 3 values r:g:b, where
6849 // - r,g,b - is rgb color components
6850 if ( i+1 >= colors.count() ) break; // format error
6851 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6852 if ( i+2 >= colors.count() ) break; // format error
6853 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6854 if ( i+3 >= colors.count() ) break; // format error
6855 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6856 nodeColor.setRgbF( r, g, b );
6859 else if ( type == "elem0d" ) {
6860 // 0d element color is set by 3 values r:g:b, where
6861 // - r,g,b - is rgb color components
6862 if ( i+1 >= colors.count() ) break; // format error
6863 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6864 if ( i+2 >= colors.count() ) break; // format error
6865 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6866 if ( i+3 >= colors.count() ) break; // format error
6867 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6868 elem0dColor.setRgbF( r, g, b );
6871 else if ( type == "ball" ) {
6872 // ball color is set by 3 values r:g:b, where
6873 // - r,g,b - is rgb color components
6874 if ( i+1 >= colors.count() ) break; // format error
6875 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6876 if ( i+2 >= colors.count() ) break; // format error
6877 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6878 if ( i+3 >= colors.count() ) break; // format error
6879 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6880 ballColor.setRgbF( r, g, b );
6883 else if ( type == "outline" ) {
6884 // outline color is set by 3 values r:g:b, where
6885 // - r,g,b - is rgb color components
6886 if ( i+1 >= colors.count() ) break; // format error
6887 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6888 if ( i+2 >= colors.count() ) break; // format error
6889 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6890 if ( i+3 >= colors.count() ) break; // format error
6891 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6892 outlineColor.setRgbF( r, g, b );
6895 else if ( type == "orientation" ) {
6896 // orientation color is set by 3 values r:g:b, where
6897 // - r,g,b - is rgb color components
6898 if ( i+1 >= colors.count() ) break; // format error
6899 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6900 if ( i+2 >= colors.count() ) break; // format error
6901 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6902 if ( i+3 >= colors.count() ) break; // format error
6903 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6904 orientationColor.setRgbF( r, g, b );
6909 if ( nodeColor.isValid() )
6910 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6912 if ( edgeColor.isValid() )
6913 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6915 if ( faceColor.isValid() )
6916 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6918 if ( volumeColor.isValid() )
6919 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6920 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6921 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6923 if ( elem0dColor.isValid() )
6924 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6926 if ( ballColor.isValid() )
6927 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6929 if ( outlineColor.isValid() )
6930 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6931 // orientation color
6932 if ( orientationColor.isValid() )
6933 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6936 else if (paramNameStr == "Sizes") {
6937 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6940 int outlineWidth = -1;
6941 int elem0dSize = -1;
6942 //int ballSize = -1;
6943 double ballDiameter = -1.0;
6944 double ballScale = -1.0;
6945 double shrinkSize = -1;
6946 double orientationSize = -1;
6947 bool orientation3d = false;
6948 for ( int i = 0; i < sizes.count(); i++ ) {
6949 QString type = sizes[i];
6950 if ( type == "line" ) {
6951 // line (wireframe) width is given as single integer value
6952 if ( i+1 >= sizes.count() ) break; // format error
6953 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6957 if ( type == "outline" ) {
6958 // outline width is given as single integer value
6959 if ( i+1 >= sizes.count() ) break; // format error
6960 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6964 else if ( type == "elem0d" ) {
6965 // 0d element size is given as single integer value
6966 if ( i+1 >= sizes.count() ) break; // format error
6967 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6971 else if ( type == "ball" ) {
6972 // balls are specified by two values: size:scale, where
6973 // - size - is a integer value specifying size
6974 // - scale - is a double value specifying scale factor
6975 if ( i+1 >= sizes.count() ) break; // format error
6976 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6977 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6978 if ( i+2 >= sizes.count() ) break; // format error
6979 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6985 else if ( type == "shrink" ) {
6986 // shrink factor is given as single floating point value
6987 if ( i+1 >= sizes.count() ) break; // format error
6988 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6992 else if ( type == "orientation" ) {
6993 // orientation vectors are specified by two values size:3d, where
6994 // - size - is a floating point value specifying scale factor
6995 // - 3d - is a boolean
6996 if ( i+1 >= sizes.count() ) break; // format error
6997 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6998 if ( i+2 >= sizes.count() ) break; // format error
6999 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7000 orientationSize = v1;
7001 orientation3d = (bool)v2;
7005 // line (wireframe) width
7006 if ( lineWidth > 0 )
7007 aSmeshActor->SetLineWidth( lineWidth );
7009 if ( outlineWidth > 0 )
7010 aSmeshActor->SetOutlineWidth( outlineWidth );
7011 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7012 aSmeshActor->SetOutlineWidth( lineWidth );
7014 if ( elem0dSize > 0 )
7015 aSmeshActor->Set0DSize( elem0dSize );
7017 /*if ( ballSize > 0 )
7018 aSmeshActor->SetBallSize( ballSize );*/
7020 if ( ballDiameter > 0 )
7021 aSmeshActor->SetBallSize( ballDiameter );
7023 if ( ballScale > 0.0 )
7024 aSmeshActor->SetBallScale( ballScale );
7026 if ( shrinkSize > 0 )
7027 aSmeshActor->SetShrinkFactor( shrinkSize );
7028 // orientation vectors
7029 if ( orientationSize > 0 ) {
7030 aSmeshActor->SetFacesOrientationScale( orientationSize );
7031 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7035 else if (paramNameStr == "PointMarker") {
7036 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7037 if( data.count() >= 2 ) {
7039 int aParam1 = data[1].toInt( &ok );
7041 if( data[0] == "std" && data.count() == 3 ) {
7042 int aParam2 = data[2].toInt( &ok );
7043 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7045 else if( data[0] == "custom" ) {
7046 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7047 if( markerIt != myMarkerMap.end() ) {
7048 VTK::MarkerData aMarkerData = markerIt->second;
7049 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7056 else if (paramNameStr == "Opacity") {
7057 aSmeshActor->SetOpacity(val.toFloat());
7060 else if (paramNameStr.startsWith("ClippingPlane")) {
7061 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7062 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7063 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7064 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7065 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7066 // new format - val looks like "Off" or "0" (plane id)
7067 // (note: in new format "Off" value is used only for consistency,
7068 // so it is processed together with values in old format)
7069 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7070 if( anIsOldFormat ) {
7071 if (paramNameStr == "ClippingPlane1" || val == "Off")
7072 aSmeshActor->RemoveAllClippingPlanes();
7074 QList<SUIT_ViewManager*> lst;
7075 getApp()->viewManagers(viewerTypStr, lst);
7076 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7077 if (viewIndex >= 0 && viewIndex < lst.count()) {
7078 SUIT_ViewManager* vman = lst.at(viewIndex);
7079 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7081 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7083 SMESH::TActorList anActorList;
7084 anActorList.push_back( aSmeshActor );
7085 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7086 aPlane->myViewWindow = vtkView;
7087 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7088 aPlane->PlaneMode = aMode;
7089 bool isOpenGLClipping = ( bool )vals[1].toInt();
7090 aPlane->IsOpenGLClipping = isOpenGLClipping;
7091 if ( aMode == SMESH::Absolute ) {
7092 aPlane->myAbsoluteOrientation = vals[2].toInt();
7093 aPlane->X = vals[3].toFloat();
7094 aPlane->Y = vals[4].toFloat();
7095 aPlane->Z = vals[5].toFloat();
7096 aPlane->Dx = vals[6].toFloat();
7097 aPlane->Dy = vals[7].toFloat();
7098 aPlane->Dz = vals[8].toFloat();
7100 else if ( aMode == SMESH::Relative ) {
7101 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7102 aPlane->myDistance = vals[3].toFloat();
7103 aPlane->myAngle[0] = vals[4].toFloat();
7104 aPlane->myAngle[1] = vals[5].toFloat();
7108 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7109 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7110 aClippingPlaneInfo.Plane = aPlane;
7111 aClippingPlaneInfo.ActorList = anActorList;
7112 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7120 int aPlaneId = val.toInt( &ok );
7121 if( ok && aPlaneId >= 0 ) {
7122 bool anIsDefinedPlane = false;
7123 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7124 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7125 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7126 TPlaneInfo& aPlaneInfo = *anIter;
7127 if( aPlaneInfo.PlaneId == aPlaneId ) {
7128 aPlaneInfo.ActorList.push_back( aSmeshActor );
7129 anIsDefinedPlane = true;
7133 if( !anIsDefinedPlane ) {
7134 TPlaneInfo aPlaneInfo;
7135 aPlaneInfo.PlaneId = aPlaneId;
7136 aPlaneInfo.ActorList.push_back( aSmeshActor );
7137 aPlaneInfo.ViewManager = vman;
7139 // to make the list sorted by plane id
7140 anIter = aPlaneInfoList.begin();
7141 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7142 const TPlaneInfo& aPlaneInfoRef = *anIter;
7143 if( aPlaneInfoRef.PlaneId > aPlaneId )
7146 aPlaneInfoList.insert( anIter, aPlaneInfo );
7151 } // if (aSmeshActor)
7152 } // other parameters than Visibility
7154 } // for names/parameters iterator
7155 } // for entries iterator
7157 // take into account planes with empty list of actors referred to them
7158 QList<SUIT_ViewManager*> aVMList;
7159 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7161 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7162 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7163 int aViewId = aPlaneDataIter->first;
7164 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7165 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7167 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7169 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7170 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7171 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7172 const TPlaneData& aPlaneData = *anIter2;
7173 int aPlaneId = aPlaneData.Id;
7175 bool anIsFound = false;
7176 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7177 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7178 const TPlaneInfo& aPlaneInfo = *anIter3;
7179 if( aPlaneInfo.PlaneId == aPlaneId ) {
7186 TPlaneInfo aPlaneInfo; // ActorList field is empty
7187 aPlaneInfo.PlaneId = aPlaneId;
7188 aPlaneInfo.ViewManager = aViewManager;
7190 // to make the list sorted by plane id
7191 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7192 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7193 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7194 if( aPlaneInfoRef.PlaneId > aPlaneId )
7197 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7203 // add clipping planes to actors according to the restored parameters
7204 // and update the clipping plane map
7205 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7206 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7207 int aViewId = anIter1->first;
7208 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7210 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7211 if( anIter2 == aPlaneDataMap.end() )
7213 const TPlaneDataList& aPlaneDataList = anIter2->second;
7215 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7216 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7217 const TPlaneInfo& aPlaneInfo = *anIter3;
7218 int aPlaneId = aPlaneInfo.PlaneId;
7219 const TActorList& anActorList = aPlaneInfo.ActorList;
7220 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7224 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7228 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7230 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7231 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7232 const TPlaneData& aPlaneData = *anIter4;
7233 if( aPlaneData.Id == aPlaneId ) {
7234 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7235 aPlane->myViewWindow = aViewWindow;
7236 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7237 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7238 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7239 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7240 aPlane->X = aPlaneData.X;
7241 aPlane->Y = aPlaneData.Y;
7242 aPlane->Z = aPlaneData.Z;
7243 aPlane->Dx = aPlaneData.Dx;
7244 aPlane->Dy = aPlaneData.Dy;
7245 aPlane->Dz = aPlaneData.Dz;
7247 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7248 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7249 aPlane->myDistance = aPlaneData.Distance;
7250 aPlane->myAngle[0] = aPlaneData.Angle[0];
7251 aPlane->myAngle[1] = aPlaneData.Angle[1];
7254 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7255 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7256 aClippingPlaneInfo.Plane = aPlane;
7257 aClippingPlaneInfo.ActorList = anActorList;
7258 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7269 // update all VTK views
7270 QList<SUIT_ViewManager*> lst;
7271 getApp()->viewManagers(lst);
7272 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7273 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7274 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7275 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7276 // set OpenGL clipping planes
7277 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7278 vtkActorCollection* anAllActors = aCopy.GetActors();
7279 anAllActors->InitTraversal();
7280 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7281 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7282 anActor->SetOpenGLClippingPlane();
7284 vtkView->getRenderer()->ResetCameraClippingRange();
7291 \brief Adds preferences for dfont of VTK viewer
7293 \param pIf group identifier
7294 \param param parameter
7295 \return identifier of preferences
7297 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7299 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7301 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7304 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7305 fam.append( tr( "SMESH_FONT_COURIER" ) );
7306 fam.append( tr( "SMESH_FONT_TIMES" ) );
7308 setPreferenceProperty( tfont, "fonts", fam );
7310 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7311 if ( needSize ) f = f | QtxFontEdit::Size;
7312 setPreferenceProperty( tfont, "features", f );
7318 \brief Actions after hypothesis edition
7319 Updates object browser after hypothesis edition
7321 void SMESHGUI::onHypothesisEdit( int result )
7324 SMESHGUI::Modified();
7325 updateObjBrowser( true );
7329 \brief Actions after choosing menu of control modes
7330 Updates control mode actions according to current selection
7332 void SMESHGUI::onUpdateControlActions()
7334 SALOME_ListIO selected;
7335 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7336 aSel->selectedObjects( selected );
7338 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7339 if ( selected.Extent() ) {
7340 if ( selected.First()->hasEntry() ) {
7341 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7342 aControl = anActor->GetControlMode();
7343 SALOME_ListIteratorOfListIO it(selected);
7344 for ( it.Next(); it.More(); it.Next() ) {
7345 Handle(SALOME_InteractiveObject) anIO = it.Value();
7346 if ( anIO->hasEntry() ) {
7347 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7348 if ( aControl != anActor->GetControlMode() ) {
7349 aControl = SMESH_Actor::eNone;
7359 int anAction = ActionToControl( aControl, true );
7361 action( anAction )->setChecked( true );
7363 QMenu* send = (QMenu*)sender();
7364 QList<QAction*> actions = send->actions();
7365 for ( int i = 0; i < actions.size(); i++ )
7366 actions[i]->setChecked( false );
7372 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7373 \param pview view being closed
7375 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7376 #ifndef DISABLE_PLOT2DVIEWER
7377 //Crear all Plot2d Viewers if need.
7378 SMESH::ClearPlot2Viewers(pview);
7380 EmitSignalCloseView();
7383 void SMESHGUI::message( const QString& msg )
7386 QStringList data = msg.split("/");
7387 if ( data.count() > 0 ) {
7388 if ( data.first() == "mesh_loading" ) {
7390 QString entry = data.count() > 1 ? data[1] : QString();
7391 if ( entry.isEmpty() )
7394 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7396 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7399 name = SMESH::fromUtf8(obj->GetName());
7400 if ( name.isEmpty() )
7403 if ( data.last() == "stop" )
7404 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7406 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7407 QApplication::processEvents();
7413 \brief Connects or disconnects signals about activating and cloning view on the module slots
7414 \param pview view which is connected/disconnected
7416 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7420 SUIT_ViewManager* viewMgr = pview->getViewManager();
7422 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7423 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7425 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7426 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7431 \brief Return \c true if object can be renamed
7433 bool SMESHGUI::renameAllowed( const QString& entry) const {
7434 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7438 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7442 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7447 if(appStudy->isComponent(entry) || obj->isReference())
7450 // check type to prevent renaming of inappropriate objects
7451 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7452 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7453 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7454 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7455 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7456 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7463 Rename object by entry.
7464 \param entry entry of the object
7465 \param name new name of the object
7466 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7468 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7470 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7474 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7479 _PTR(Study) aStudy = appStudy->studyDS();
7484 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7486 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7491 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7492 _PTR(GenericAttribute) anAttr;
7493 _PTR(AttributeName) aName;
7495 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7497 // check type to prevent renaming of inappropriate objects
7498 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7499 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7500 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7501 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7502 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7503 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7504 if ( !name.isEmpty() ) {
7505 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7507 // update name of group object and its actor
7508 Handle(SALOME_InteractiveObject) IObject =
7509 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7511 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7512 if( !aGroupObject->_is_nil() ) {
7513 aGroupObject->SetName( qUtf8Printable(name) );
7514 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7515 anActor->setName( qUtf8Printable(name) );
7525 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7527 static QList<QColor> colors;
7529 if ( colors.isEmpty() ) {
7531 for (int s = 0; s < 2 ; s++)
7533 for (int v = 100; v >= 40; v = v - 20)
7535 for (int h = 0; h < 359 ; h = h + 60)
7537 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7542 static int currentColor = randomize( colors.size() );
7544 SALOMEDS::Color color;
7545 color.R = (double)colors[currentColor].red() / 255.0;
7546 color.G = (double)colors[currentColor].green() / 255.0;
7547 color.B = (double)colors[currentColor].blue() / 255.0;
7549 currentColor = (currentColor+1) % colors.count();