1 // Copyright (C) 2007-2015 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_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
86 #include "SMESHGUI_FilterUtils.h"
87 #include "SMESHGUI_GEOMGenUtils.h"
88 #include "SMESHGUI_GroupUtils.h"
89 #include "SMESHGUI_HypothesesUtils.h"
90 #include "SMESHGUI_MeshUtils.h"
91 #include "SMESHGUI_PatternUtils.h"
92 #include "SMESHGUI_Utils.h"
93 #include "SMESHGUI_VTKUtils.h"
95 #include "SMESH_version.h"
97 #include "SMESH_ControlsDef.hxx"
98 #include "SMESH_Actor.h"
99 #include "SMESH_ActorUtils.h"
100 #include "SMESH_Client.hxx"
101 #include "SMESH_ScalarBarActor.h"
102 #include "SMESH_TypeFilter.hxx"
104 // SALOME GUI includes
105 #include <SalomeApp_Application.h>
106 #include <SalomeApp_CheckFileDlg.h>
107 #include <SalomeApp_DataObject.h>
108 #include <SalomeApp_Study.h>
109 #include <SalomeApp_Tools.h>
111 #include <LightApp_DataOwner.h>
112 #include <LightApp_NameDlg.h>
113 #include <LightApp_Preferences.h>
114 #include <LightApp_SelectionMgr.h>
115 #include <LightApp_UpdateFlags.h>
117 #include <SVTK_ViewManager.h>
118 #include <SVTK_ViewModel.h>
119 #include <SVTK_ViewWindow.h>
121 #include <VTKViewer_Algorithm.h>
123 #include <PyInterp_Interp.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
157 #include <boost/shared_ptr.hpp>
160 #include <vtkCallbackCommand.h>
161 #include <vtkCamera.h>
162 #include <vtkLookupTable.h>
163 #include <vtkPlane.h>
164 #include <vtkRenderer.h>
166 // SALOME KERNEL includes
167 #include <SALOMEDSClient_ClientFactory.hxx>
168 #include <SALOMEDSClient_IParameters.hxx>
169 #include <SALOMEDSClient_SComponent.hxx>
170 #include <SALOMEDSClient_StudyBuilder.hxx>
171 #include <SALOMEDS_Study.hxx>
172 #include <SALOMEDS_SObject.hxx>
173 #include "utilities.h"
176 #include <Standard_ErrorHandler.hxx>
177 #include <NCollection_DataMap.hxx>
179 #include <Basics_Utils.hxx>
181 //To disable automatic genericobj management, the following line should be commented.
182 //Otherwise, it should be uncommented.
183 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
184 #define WITHGENERICOBJ
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ) {
219 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
220 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
222 else if ( theCommandID == SMESHOp::OpImportUNV ) {
223 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
225 else if ( theCommandID == SMESHOp::OpImportDAT ) {
226 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
228 else if ( theCommandID == SMESHOp::OpImportSTL ) {
229 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
232 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
233 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
236 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
237 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
238 filter.append( QObject::tr( "All files (*)" ) );
240 else if ( theCommandID == SMESHOp::OpImportGMF ) {
241 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
242 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
245 QString anInitialPath = "";
246 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
247 anInitialPath = QDir::currentPath();
249 QStringList filenames;
250 bool toCreateGroups = true;
252 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
253 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
254 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
255 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
256 // fd->setNameFilters( filter );
257 // fd->SetChecked( true );
259 // filenames << fd->selectedFile();
260 // toCreateGroups = fd->IsChecked();
266 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
269 QObject::tr( "SMESH_IMPORT_MESH" ) );
271 if ( filenames.count() > 0 ) {
272 SUIT_OverrideCursor wc;
273 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
276 QStringList anEntryList;
277 bool isEmpty = false;
278 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
279 QString filename = *it;
280 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
282 switch ( theCommandID ) {
283 case SMESHOp::OpImportDAT:
285 // DAT format (currently unsupported)
286 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
287 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
290 case SMESHOp::OpImportUNV:
293 aMeshes->length( 1 );
294 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
295 if ( aMeshes[0]->_is_nil() )
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
300 case SMESHOp::OpImportMED:
303 SMESH::DriverMED_ReadStatus res;
304 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
305 if ( res != SMESH::DRS_OK ) {
306 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
307 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
311 case SMESHOp::OpImportSTL:
314 aMeshes->length( 1 );
315 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
316 if ( aMeshes[0]->_is_nil() ) {
317 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
318 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
323 case SMESHOp::OpImportCGNS:
326 SMESH::DriverMED_ReadStatus res;
327 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
328 if ( res != SMESH::DRS_OK ) {
329 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
330 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
335 case SMESHOp::OpImportSAUV:
338 SMESH::DriverMED_ReadStatus res;
339 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
340 if ( res != SMESH::DRS_OK ) {
341 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
342 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
346 case SMESHOp::OpImportGMF:
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++ ) {
372 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
374 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
375 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
376 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
377 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
378 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
380 anEntryList.append( aMeshSO->GetID().c_str() );
388 // update Object browser
389 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
391 // browse to the published meshes
392 if( LightApp_Application* anApp =
393 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
394 anApp->browseObjects( anEntryList );
396 // show Error message box if there were errors
397 if ( errors.count() > 0 ) {
398 SUIT_MessageBox::critical( SMESHGUI::desktop(),
399 QObject::tr( "SMESH_ERROR" ),
400 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
403 // show warning message box, if some imported mesh is empty
405 SUIT_MessageBox::warning( SMESHGUI::desktop(),
406 QObject::tr( "SMESH_WRN_WARNING" ),
407 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
412 //================================================================================
414 * \brief Export selected meshes or groups into a file
416 //================================================================================
418 void ExportMeshToFile( int theCommandID )
420 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
421 SALOME_ListIO selected;
423 aSel->selectedObjects( selected );
425 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
426 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
427 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
428 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
430 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
432 const bool isCGNS= false;
434 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
435 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
437 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
438 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
441 // get mesh object from selection and check duplication of their names
442 bool hasDuplicatedMeshNames = false;
443 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
444 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
445 SALOME_ListIteratorOfListIO It( selected );
446 for( ; It.More(); It.Next() )
448 Handle(SALOME_InteractiveObject) anIObject = It.Value();
449 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
450 if ( aMeshItem->_is_nil() ) {
451 SUIT_MessageBox::warning( SMESHGUI::desktop(),
452 QObject::tr( "SMESH_WRN_WARNING" ),
453 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
457 QString aMeshName = anIObject->getName();
459 // check for name duplications
460 if ( !hasDuplicatedMeshNames )
461 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
462 if( aMeshName == (*aMeshIter).second ) {
463 hasDuplicatedMeshNames = true;
468 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
471 if( hasDuplicatedMeshNames && isMED ) {
472 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
473 QObject::tr("SMESH_WRN_WARNING"),
474 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
475 QObject::tr("SMESH_BUT_YES"),
476 QObject::tr("SMESH_BUT_NO"), 0, 1);
481 aMeshIter = aMeshList.begin();
482 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
483 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
484 QString aMeshName = (*aMeshIter).second;
486 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
488 // check for equal group names within each mesh
489 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
490 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
491 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
492 int aRet = SUIT_MessageBox::warning
493 (SMESHGUI::desktop(),
494 QObject::tr("SMESH_WRN_WARNING"),
495 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
496 QObject::tr("SMESH_BUT_YES"),
497 QObject::tr("SMESH_BUT_NO"), 0, 1);
504 // Warn the user about presence of not supported elements
506 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
510 notSupportedElemTypes.push_back( SMESH::Entity_0D );
511 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
516 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
517 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
518 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
519 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
520 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
521 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
522 notSupportedElemTypes.push_back( SMESH::Entity_0D );
523 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
528 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
529 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
530 notSupportedElemTypes.push_back( SMESH::Entity_0D );
531 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
536 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
537 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
542 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
543 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
544 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
545 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
546 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
547 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
548 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
553 notSupportedElemTypes.push_back( SMESH::Entity_0D );
554 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
558 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
563 if ( ! notSupportedElemTypes.empty() )
565 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
566 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
567 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
568 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
570 if ( !presentNotSupported.empty() )
573 const char* typeMsg[SMESH::Entity_Last] = {
574 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
575 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
576 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
577 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
578 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
579 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
580 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
581 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
583 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
584 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
585 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
586 if ( iType != presentNotSupported.size() - 1 )
587 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
589 int aRet = SUIT_MessageBox::warning
590 (SMESHGUI::desktop(),
591 QObject::tr("SMESH_WRN_WARNING"),
592 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
593 QObject::tr("SMESH_BUT_YES"),
594 QObject::tr("SMESH_BUT_NO"), 0, 1);
599 // Get parameters of export operation
602 SMESH::MED_VERSION aFormat;
603 // Init the parameters with the default values
604 bool aIsASCII_STL = true;
605 bool toCreateGroups = false;
606 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
608 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
609 bool toOverwrite = true;
610 bool toFindOutDim = true;
612 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
613 QString anInitialPath = "";
614 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
615 anInitialPath = QDir::currentPath();
617 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
619 // Get a file name to write in and additional otions
620 if ( isUNV || isDAT || isGMF ) // Export w/o options
623 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
625 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
627 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
628 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
629 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
630 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
631 anInitialPath + QString("/") + aMeshName,
632 aFilter, aTitle, false);
634 else if ( isCGNS )// Export to CGNS
636 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
637 fd->setWindowTitle( aTitle );
638 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
639 if ( !anInitialPath.isEmpty() )
640 fd->setDirectory( anInitialPath );
641 fd->selectFile(aMeshName);
642 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
643 fd->setValidator( fv );
646 aFilename = fd->selectedFile();
647 toOverwrite = fv->isOverwrite();
651 else if ( isSTL ) // Export to STL
653 QMap<QString, int> aFilterMap;
654 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
655 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
658 QMap<QString, int>::const_iterator it = aFilterMap.begin();
659 for ( ; it != aFilterMap.end(); ++it )
660 filters.push_back( it.key() );
662 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
663 fd->setWindowTitle( aTitle );
664 fd->setNameFilters( filters );
665 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
666 if ( !anInitialPath.isEmpty() )
667 fd->setDirectory( anInitialPath );
668 fd->selectFile(aMeshName);
672 aFilename = fd->selectedFile();
673 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
678 else if ( isMED || isSAUV ) // Export to MED or SAUV
680 QMap<QString, SMESH::MED_VERSION> aFilterMap;
681 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
683 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
684 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
685 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
688 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
689 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
690 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
694 QString aDefaultFilter;
695 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
696 for ( ; it != aFilterMap.end(); ++it ) {
697 filters.push_back( it.key() );
698 if (it.value() == SMESH::MED_V2_2)
699 aDefaultFilter = it.key();
701 QStringList checkBoxes;
702 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
704 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
705 QList< QWidget* > wdgList;
706 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
707 wdgList.append( fieldSelWdg );
709 SalomeApp_CheckFileDlg* fd =
710 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
711 fd->setWindowTitle( aTitle );
712 fd->setNameFilters( filters );
713 fd->selectNameFilter( aDefaultFilter );
714 fd->SetChecked( toCreateGroups, 0 );
715 fd->SetChecked( toFindOutDim, 1 );
716 if ( !anInitialPath.isEmpty() )
717 fd->setDirectory( anInitialPath );
718 fd->selectFile(aMeshName);
721 QListView *lview = fd->findChild<QListView*>("listView");
723 lview->setMinimumHeight(200);
725 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
727 tview->setMinimumHeight(200);
730 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
731 fd->setValidator( fv );
736 aFilename = fd->selectedFile();
738 aFilename = QString::null;
741 aFormat = aFilterMap[fd->selectedNameFilter()];
742 toOverwrite = fv->isOverwrite();
744 if ( !aFilename.isEmpty() ) {
745 // med-2.1 does not support poly elements
746 if ( aFormat==SMESH::MED_V2_1 )
747 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
748 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
749 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
750 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
751 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
753 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
754 QObject::tr("SMESH_WRN_WARNING"),
755 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
756 QObject::tr("SMESH_BUT_YES"),
757 QObject::tr("SMESH_BUT_NO"), 0, 1);
765 // can't append to an existing using other format
766 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
767 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
768 if( !isVersionOk || aVersion != aFormat ) {
769 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
770 QObject::tr("SMESH_WRN_WARNING"),
771 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
772 QObject::tr("SMESH_BUT_YES"),
773 QObject::tr("SMESH_BUT_NO"), 0, 1);
780 QStringList aMeshNamesCollisionList;
781 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
782 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
783 QString anExistingMeshName( aMeshNames[ i ] );
784 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
785 QString anExportMeshName = (*aMeshIter).second;
786 if( anExportMeshName == anExistingMeshName ) {
787 aMeshNamesCollisionList.append( anExportMeshName );
792 if( !aMeshNamesCollisionList.isEmpty() ) {
793 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
794 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
795 QObject::tr("SMESH_WRN_WARNING"),
796 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
797 QObject::tr("SMESH_BUT_YES"),
798 QObject::tr("SMESH_BUT_NO"),
799 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
808 toCreateGroups = fd->IsChecked(0);
809 toFindOutDim = fd->IsChecked(1);
810 fieldSelWdg->GetSelectedFeilds();
811 if ( !fieldSelWdg->parent() )
822 if ( !aFilename.isEmpty() ) {
823 // Check whether the file already exists and delete it if yes
824 QFile aFile( aFilename );
825 if ( aFile.exists() && toOverwrite )
827 SUIT_OverrideCursor wc;
830 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
831 // bool Renumber = false;
832 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
834 // Renumber= resMgr->booleanValue("renumbering");
836 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
837 // aMeshEditor->RenumberNodes();
838 // aMeshEditor->RenumberElements();
839 // if ( SMESHGUI::automaticUpdate() )
840 // SMESH::UpdateView();
844 aMeshIter = aMeshList.begin();
845 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
847 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
848 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
849 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
850 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
851 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
852 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
853 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
854 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
856 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
857 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
858 fields, geoAssFields.toLatin1().data() );
863 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
865 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
866 if( !aMeshItem->_is_nil() )
867 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
872 if ( aMeshOrGroup->_is_equivalent( aMesh ))
873 aMesh->ExportDAT( aFilename.toUtf8().data() );
875 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
879 if ( aMeshOrGroup->_is_equivalent( aMesh ))
880 aMesh->ExportUNV( aFilename.toUtf8().data() );
882 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
886 if ( aMeshOrGroup->_is_equivalent( aMesh ))
887 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
889 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
893 aMeshIter = aMeshList.begin();
894 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
896 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
897 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
898 aMeshItem->ExportCGNS( aMeshOrGroup,
899 aFilename.toUtf8().data(),
900 toOverwrite && aMeshIndex == 0 );
905 toCreateGroups = true;
906 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
909 catch (const SALOME::SALOME_Exception& S_ex){
911 SUIT_MessageBox::warning(SMESHGUI::desktop(),
912 QObject::tr("SMESH_WRN_WARNING"),
913 QObject::tr("SMESH_EXPORT_FAILED"));
919 inline void InverseEntityMode(unsigned int& theOutputMode,
920 unsigned int theMode)
922 bool anIsNotPresent = ~theOutputMode & theMode;
924 theOutputMode |= theMode;
926 theOutputMode &= ~theMode;
929 void SetDisplayEntity(int theCommandID){
930 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
931 SALOME_ListIO selected;
933 aSel->selectedObjects( selected );
935 if(selected.Extent() >= 1){
936 SALOME_ListIteratorOfListIO It( selected );
937 for( ; It.More(); It.Next()){
938 Handle(SALOME_InteractiveObject) IObject = It.Value();
939 if(IObject->hasEntry()){
940 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
941 unsigned int aMode = anActor->GetEntityMode();
942 switch(theCommandID){
943 case SMESHOp::OpDE0DElements:
944 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
946 case SMESHOp::OpDEEdges:
947 InverseEntityMode(aMode,SMESH_Actor::eEdges);
949 case SMESHOp::OpDEFaces:
950 InverseEntityMode(aMode,SMESH_Actor::eFaces);
952 case SMESHOp::OpDEVolumes:
953 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
955 case SMESHOp::OpDEBalls:
956 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
958 case SMESHOp::OpDEAllEntity:
959 aMode = SMESH_Actor::eAllEntity;
963 anActor->SetEntityMode(aMode);
972 SALOME_ListIO selected;
973 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
977 LightApp_SelectionMgr* aSel = app->selectionMgr();
978 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
979 if( !aSel || !appStudy )
982 aSel->selectedObjects( selected );
983 if( selected.IsEmpty() )
986 Handle(SALOME_InteractiveObject) anIObject = selected.First();
988 _PTR(Study) aStudy = appStudy->studyDS();
989 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
990 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
991 if( aMainObject->_is_nil() )
994 SUIT_OverrideCursor wc;
996 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
998 QList<SALOMEDS::Color> aReservedColors;
1000 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1001 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1003 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1004 //SALOMEDS::Color aColor = aGroupObject->GetColor();
1006 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1007 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1008 #else // old algorithm for auto-colors
1009 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1010 aReservedColors.append( aColor );
1011 #endif // SIMPLE_AUTOCOLOR
1012 aGroupObject->SetColor( aColor );
1014 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1015 if (aGroupSObject) {
1018 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1019 switch ( aGroupObject->GetType ()) {
1021 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1023 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1025 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1027 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1029 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1030 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1033 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1034 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1040 SMESH::RepaintCurrentView();
1043 void OverallMeshQuality() {
1044 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1045 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1046 SALOME_ListIO selected;
1048 aSel->selectedObjects( selected );
1050 if ( selected.IsEmpty() ) return;
1051 SALOME_ListIteratorOfListIO It( selected );
1052 for ( ; It.More(); It.Next() ) {
1053 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1054 ctrlDlg->showInfo( It.Value() );
1059 QString functorToString( SMESH::Controls::FunctorPtr f )
1061 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1062 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1063 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1064 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1065 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1066 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1067 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1068 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1069 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1070 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1071 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1072 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1073 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1074 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1075 type = QObject::tr( "WARP_ELEMENTS" );
1076 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1077 type = QObject::tr( "TAPER_ELEMENTS" );
1078 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1079 type = QObject::tr( "SKEW_ELEMENTS" );
1080 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1081 type = QObject::tr( "AREA_ELEMENTS" );
1082 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1083 type = QObject::tr( "LENGTH_EDGES" );
1084 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1085 type = QObject::tr( "LENGTH2D_EDGES" );
1086 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1087 type = QObject::tr( "MULTI_BORDERS" );
1088 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1089 type = QObject::tr( "MULTI2D_BORDERS" );
1090 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1091 type = QObject::tr( "FREE_NODES" );
1092 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1093 type = QObject::tr( "FREE_EDGES" );
1094 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1095 type = QObject::tr( "FREE_BORDERS" );
1096 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1097 type = QObject::tr( "FREE_FACES" );
1098 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1099 type = QObject::tr( "BARE_BORDER_VOLUME" );
1100 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1101 type = QObject::tr( "BARE_BORDER_FACE" );
1102 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1103 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1104 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1105 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1106 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1107 type = QObject::tr( "EQUAL_NODE" );
1108 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1109 type = QObject::tr( "EQUAL_EDGE" );
1110 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1111 type = QObject::tr( "EQUAL_FACE" );
1112 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1113 type = QObject::tr( "EQUAL_VOLUME" );
1117 void SaveDistribution()
1119 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1120 SALOME_ListIO selected;
1122 aSel->selectedObjects( selected );
1124 if ( selected.Extent() == 1 ) {
1125 Handle(SALOME_InteractiveObject) anIO = selected.First();
1126 if ( anIO->hasEntry() ) {
1127 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1128 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1129 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1130 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1131 if ( aScalarBarActor && aFunctor ) {
1132 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1134 std::vector<int> elements;
1135 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1136 if ( mesh->_is_nil() ) {
1137 SMESH::SMESH_IDSource_var idSource =
1138 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1139 if ( !idSource->_is_nil() )
1141 SMESH::long_array_var ids = idSource->GetIDs();
1142 elements.resize( ids->length() );
1143 for ( unsigned i = 0; i < elements.size(); ++i )
1144 elements[i] = ids[i];
1147 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1148 vtkLookupTable* lookupTable =
1149 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1150 double * minmax = lookupTable->GetRange();
1151 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1152 std::vector<int> nbEvents;
1153 std::vector<double> funValues;
1154 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1155 QString anInitialPath = "";
1156 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1157 anInitialPath = QDir::currentPath();
1158 QString aMeshName = anIO->getName();
1160 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1161 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1162 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1163 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1164 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1167 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1169 if ( !aFilename.isEmpty() ) {
1170 QFile f( aFilename );
1171 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1172 QTextStream out( &f );
1173 out << "# Mesh: " << aMeshName << endl;
1174 out << "# Control: " << functorToString( aFunctor ) << endl;
1176 out.setFieldWidth( 10 );
1177 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1178 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1189 void ShowElement(int theCommandID ) {
1190 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1191 SALOME_ListIO selected;
1193 aSel->selectedObjects( selected );
1195 if ( selected.Extent() == 1 ) {
1196 Handle(SALOME_InteractiveObject) anIO = selected.First();
1197 if ( anIO->hasEntry() ) {
1198 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1199 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1200 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1201 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1202 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1204 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1205 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1212 #ifndef DISABLE_PLOT2DVIEWER
1213 void PlotDistribution() {
1214 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1218 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1219 SALOME_ListIO selected;
1221 aSel->selectedObjects( selected );
1223 if ( selected.Extent() == 1 ) {
1224 Handle(SALOME_InteractiveObject) anIO = selected.First();
1225 if ( anIO->hasEntry() ) {
1226 //Find Actor by entry before getting Plot2d viewer,
1227 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1228 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1230 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1235 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1239 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1243 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1244 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1245 QString functorName = functorToString( anActor->GetFunctor());
1246 QString aHistogramName("%1 : %2");
1247 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1248 aHistogram->setName(aHistogramName);
1249 aHistogram->setHorTitle(functorName);
1250 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1251 aPlot->displayObject(aHistogram, true);
1256 #endif //DISABLE_PLOT2DVIEWER
1258 void DisableAutoColor(){
1259 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1260 SALOME_ListIO selected;
1262 aSel->selectedObjects( selected );
1264 if(selected.Extent()){
1265 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1266 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1267 if ( !aMesh->_is_nil() ) {
1268 aMesh->SetAutoColor( false );
1273 void sortChildren(){
1274 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1275 SALOME_ListIO selected;
1277 aSel->selectedObjects( selected );
1279 if(selected.Extent()){
1280 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1281 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1282 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1284 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1285 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1292 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1294 SALOME_ListIO selected;
1295 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1299 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1300 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1301 if( !aSel || !appStudy )
1304 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1305 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1306 aModule->EmitSignalDeactivateDialog();
1307 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1308 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1313 _PTR(Study) aStudy = appStudy->studyDS();
1315 aSel->selectedObjects( selected );
1317 if(selected.Extent() >= 1){
1318 switch(theCommandID){
1319 case SMESHOp::OpTransparency:{
1320 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1321 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1324 case SMESHOp::OpProperties: {
1326 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1327 QColor orientationColor, outlineColor, volumeColor;
1328 int deltaF = 0, deltaV = 0;
1331 double ballScale = 1.0;
1333 int outlineWidth = 1;
1334 double shrinkCoef = 0.0;
1335 double orientationScale = 0.0;
1336 bool orientation3d = false;
1337 VTK::MarkerType markerType = VTK::MT_NONE;
1338 VTK::MarkerScale markerScale = VTK::MS_NONE;
1340 bool hasNodes = false;
1341 int presentEntities = 0;
1342 bool firstTime = true;
1344 SALOME_ListIteratorOfListIO It( selected );
1345 for ( ; It.More(); It.Next() ) {
1346 Handle(SALOME_InteractiveObject) IObject = It.Value();
1347 if ( !IObject->hasEntry() ) continue;
1348 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1349 if ( !anActor || !anActor->GetObject() ) continue;
1352 // nodes: color, marker
1353 anActor->GetNodeColor( color[0], color[1], color[2] );
1354 nodeColor.setRgbF( color[0], color[1], color[2] );
1355 markerType = anActor->GetMarkerType();
1356 markerScale = anActor->GetMarkerScale();
1357 markerId = anActor->GetMarkerTexture();
1358 // edges: color, width
1359 anActor->GetEdgeColor( color[0], color[1], color[2] );
1360 edgeColor.setRgbF( color[0], color[1], color[2] );
1361 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1362 // faces: front color, back color (delta)
1363 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1364 faceColor.setRgbF( color[0], color[1], color[2] );
1365 // faces: front color, back color (delta)
1366 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1367 volumeColor.setRgbF( color[0], color[1], color[2] );
1368 // 0d elements: color, size
1369 anActor->Get0DColor( color[0], color[1], color[2] );
1370 elem0dColor.setRgbF( color[0], color[1], color[2] );
1371 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1372 // balls: color, size
1373 anActor->GetBallColor( color[0], color[1], color[2] );
1374 ballColor.setRgbF( color[0], color[1], color[2] );
1375 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1376 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1378 anActor->GetOutlineColor( color[0], color[1], color[2] );
1379 outlineColor.setRgbF( color[0], color[1], color[2] );
1380 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1381 // orientation vectors: color, scale, 3d flag
1382 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1383 orientationColor.setRgbF( color[0], color[1], color[2] );
1384 orientationScale = anActor->GetFacesOrientationScale();
1385 orientation3d = anActor->GetFacesOrientation3DVectors();
1387 shrinkCoef = anActor->GetShrinkFactor();
1390 firstTime = false; // we only take properties from first object (for performance reasons)
1393 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1394 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1395 presentEntities = presentEntities | SMESH_Actor::eEdges;
1396 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1397 presentEntities = presentEntities | SMESH_Actor::eFaces;
1398 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1399 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1400 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1401 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1402 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1403 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1405 // as we know that all types of elements are present, we can exit the loop
1406 if ( presentEntities == SMESH_Actor::eAllEntity )
1410 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1411 // nodes: color, marker
1412 dlg.setNodeColor( nodeColor );
1413 if( markerType != VTK::MT_USER )
1414 dlg.setNodeMarker( markerType, markerScale );
1416 dlg.setNodeCustomMarker( markerId );
1417 // edges: color, line width
1418 dlg.setEdgeColor( edgeColor );
1419 dlg.setEdgeWidth( edgeWidth );
1420 // faces: front color, back color
1421 dlg.setFaceColor( faceColor, deltaF );
1422 // volumes: normal color, reversed color
1423 dlg.setVolumeColor( volumeColor, deltaV );
1424 // outlines: color, line width
1425 dlg.setOutlineColor( outlineColor );
1426 dlg.setOutlineWidth( outlineWidth );
1427 // 0d elements: color, size
1428 dlg.setElem0dColor( elem0dColor );
1429 dlg.setElem0dSize( elem0dSize );
1430 // balls: color, size
1431 dlg.setBallColor( ballColor );
1432 //dlg.setBallSize( ballSize );
1433 dlg.setBallScale( ballScale );
1434 // orientation: color, scale, 3d flag
1435 dlg.setOrientationColor( orientationColor );
1436 dlg.setOrientationSize( int( orientationScale * 100. ) );
1437 dlg.setOrientation3d( orientation3d );
1438 // shrink: scale factor
1439 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1440 // hide unused controls
1441 dlg.showControls( presentEntities, hasNodes );
1444 nodeColor = dlg.nodeColor();
1445 markerType = dlg.nodeMarkerType();
1446 markerScale = dlg.nodeMarkerScale();
1447 markerId = dlg.nodeMarkerId();
1448 edgeColor = dlg.edgeColor();
1449 edgeWidth = dlg.edgeWidth();
1450 faceColor = dlg.faceColor();
1451 deltaF = dlg.faceColorDelta();
1452 volumeColor = dlg.volumeColor();
1453 deltaV = dlg.volumeColorDelta();
1454 outlineColor = dlg.outlineColor();
1455 outlineWidth = dlg.outlineWidth();
1456 elem0dColor = dlg.elem0dColor();
1457 elem0dSize = dlg.elem0dSize();
1458 ballColor = dlg.ballColor();
1459 // ballSize = dlg.ballSize();
1460 ballScale = dlg.ballScale();
1461 orientationColor = dlg.orientationColor();
1462 orientationScale = dlg.orientationSize() / 100.;
1463 orientation3d = dlg.orientation3d();
1464 shrinkCoef = dlg.shrinkCoef() / 100.;
1466 // store point markers map that might be changed by the user
1467 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1469 // set properties from dialog box to the presentations
1470 SALOME_ListIteratorOfListIO It( selected );
1471 for ( ; It.More(); It.Next() ) {
1472 Handle(SALOME_InteractiveObject) IObject = It.Value();
1473 if ( !IObject->hasEntry() ) continue;
1474 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1475 if ( !anActor ) continue;
1477 // nodes: color, marker
1478 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1479 if ( markerType != VTK::MT_USER ) {
1480 anActor->SetMarkerStd( markerType, markerScale );
1483 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1484 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1485 if ( iter != markerMap.end() )
1486 anActor->SetMarkerTexture( markerId, iter->second.second );
1488 // volumes: normal color, reversed color (delta)
1489 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1490 // faces: front color, back color (delta)
1491 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1492 // edges: color, width
1493 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1494 anActor->SetLineWidth( edgeWidth );
1496 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1497 anActor->SetOutlineWidth( outlineWidth );
1498 // 0D elements: color, size
1499 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1500 anActor->Set0DSize( elem0dSize );
1501 // balls: color, size
1502 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1503 // anActor->SetBallSize( ballSize );
1504 anActor->SetBallScale( ballScale );
1505 // orientation: color, scale, 3d flag
1506 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1507 anActor->SetFacesOrientationScale( orientationScale );
1508 anActor->SetFacesOrientation3DVectors( orientation3d );
1510 anActor->SetShrinkFactor( shrinkCoef );
1512 // for groups, set also proper color
1513 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1514 if ( !aGroupObject->_is_nil() ) {
1515 SMESH::ElementType anElementType = aGroupObject->GetType();
1517 switch( anElementType ) {
1519 aColor = nodeColor; break;
1521 aColor = edgeColor; break;
1523 aColor = faceColor; break;
1525 aColor = volumeColor; break;
1527 aColor = elem0dColor; break;
1529 aColor = ballColor; break;
1533 if ( aColor.isValid() ) {
1534 SALOMEDS::Color aGroupColor;
1535 aGroupColor.R = aColor.redF();
1536 aGroupColor.G = aColor.greenF();
1537 aGroupColor.B = aColor.blueF();
1538 aGroupObject->SetColor( aGroupColor );
1540 } // if ( !aGroupObject->_is_nil() )
1541 } // for ( ; It.More(); It.Next() )
1542 SMESH::RepaintCurrentView();
1543 } // if ( dlg.exec() )
1545 } // case SMESHOp::OpProperties:
1546 } // switch(theCommandID)
1547 SALOME_ListIteratorOfListIO It( selected );
1548 for( ; It.More(); It.Next()){
1549 Handle(SALOME_InteractiveObject) IObject = It.Value();
1550 if(IObject->hasEntry()){
1551 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1552 switch(theCommandID){
1553 case SMESHOp::OpDMWireframe:
1554 anActor->SetRepresentation(SMESH_Actor::eEdge);
1556 case SMESHOp::OpDMShading:
1557 anActor->SetRepresentation(SMESH_Actor::eSurface);
1559 case SMESHOp::OpDMShrink:
1560 if(anActor->IsShrunk())
1561 anActor->UnShrink();
1563 anActor->SetShrink();
1565 case SMESHOp::OpDMNodes:
1566 anActor->SetRepresentation(SMESH_Actor::ePoint);
1568 case SMESHOp::OpRepresentationLines:
1569 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1570 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1572 case SMESHOp::OpRepresentationArcs:
1573 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1574 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1580 SMESH::RepaintCurrentView();
1584 void Control( int theCommandID )
1586 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1587 switch ( theCommandID ){
1588 case SMESHOp::OpFreeNode:
1589 aControl = SMESH_Actor::eFreeNodes;
1591 case SMESHOp::OpEqualNode:
1592 aControl = SMESH_Actor::eCoincidentNodes;
1594 case SMESHOp::OpFreeEdge:
1595 aControl = SMESH_Actor::eFreeEdges;
1597 case SMESHOp::OpFreeBorder:
1598 aControl = SMESH_Actor::eFreeBorders;
1600 case SMESHOp::OpLength:
1601 aControl = SMESH_Actor::eLength;
1603 case SMESHOp::OpConnection:
1604 aControl = SMESH_Actor::eMultiConnection;
1606 case SMESHOp::OpEqualEdge:
1607 aControl = SMESH_Actor::eCoincidentElems1D;
1609 case SMESHOp::OpFreeFace:
1610 aControl = SMESH_Actor::eFreeFaces;
1612 case SMESHOp::OpBareBorderFace:
1613 aControl = SMESH_Actor::eBareBorderFace;
1615 case SMESHOp::OpOverConstrainedFace:
1616 aControl = SMESH_Actor::eOverConstrainedFace;
1618 case SMESHOp::OpLength2D:
1619 aControl = SMESH_Actor::eLength2D;
1621 case SMESHOp::OpConnection2D:
1622 aControl = SMESH_Actor::eMultiConnection2D;
1624 case SMESHOp::OpArea:
1625 aControl = SMESH_Actor::eArea;
1627 case SMESHOp::OpTaper:
1628 aControl = SMESH_Actor::eTaper;
1630 case SMESHOp::OpAspectRatio:
1631 aControl = SMESH_Actor::eAspectRatio;
1633 case SMESHOp::OpMinimumAngle:
1634 aControl = SMESH_Actor::eMinimumAngle;
1636 case SMESHOp::OpWarpingAngle:
1637 aControl = SMESH_Actor::eWarping;
1639 case SMESHOp::OpSkew:
1640 aControl = SMESH_Actor::eSkew;
1642 case SMESHOp::OpMaxElementLength2D:
1643 aControl = SMESH_Actor::eMaxElementLength2D;
1645 case SMESHOp::OpEqualFace:
1646 aControl = SMESH_Actor:: eCoincidentElems2D;
1648 case SMESHOp::OpAspectRatio3D:
1649 aControl = SMESH_Actor::eAspectRatio3D;
1651 case SMESHOp::OpVolume:
1652 aControl = SMESH_Actor::eVolume3D;
1654 case SMESHOp::OpMaxElementLength3D:
1655 aControl = SMESH_Actor::eMaxElementLength3D;
1657 case SMESHOp::OpBareBorderVolume:
1658 aControl = SMESH_Actor::eBareBorderVolume;
1660 case SMESHOp::OpOverConstrainedVolume:
1661 aControl = SMESH_Actor::eOverConstrainedVolume;
1663 case SMESHOp::OpEqualVolume:
1664 aControl = SMESH_Actor::eCoincidentElems3D;
1667 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1668 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1669 SALOME_ListIO selected;
1671 aSel->selectedObjects( selected );
1673 if( !selected.IsEmpty() ){
1674 SALOME_ListIteratorOfListIO It(selected);
1675 for ( ; It.More(); It.Next())
1677 Handle(SALOME_InteractiveObject) anIO = It.Value();
1679 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1681 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1682 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1683 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1684 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1685 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1686 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1687 anActor->SetControlMode(aControl);
1688 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1689 SMESH::RepaintCurrentView();
1690 #ifndef DISABLE_PLOT2DVIEWER
1691 if(anActor->GetPlot2Histogram()) {
1692 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1693 QString functorName = functorToString( anActor->GetFunctor());
1694 QString aHistogramName("%1 : %2");
1695 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1696 aHistogram->setName(aHistogramName);
1697 aHistogram->setHorTitle(functorName);
1698 SMESH::ProcessIn2DViewers(anActor);
1710 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1711 SMESH::MeshObjectType theType,
1712 const QString theInTypeName,
1713 QString & theOutTypeName)
1715 SMESH_TypeFilter aTypeFilter( theType );
1717 if( !theIO.IsNull() )
1719 entry = theIO->getEntry();
1720 LightApp_DataOwner owner( entry );
1721 if ( aTypeFilter.isOk( &owner )) {
1722 theOutTypeName = theInTypeName;
1730 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1732 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1733 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1735 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1736 CORBA::String_var anID = aSComp->GetID().c_str();
1737 if (!strcmp(anID.in(),theIO->getEntry()))
1743 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1744 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1745 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1746 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1747 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1755 QString CheckHomogeneousSelection()
1757 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1758 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1759 SALOME_ListIO selected;
1761 aSel->selectedObjects( selected );
1763 QString RefType = CheckTypeObject(selected.First());
1764 SALOME_ListIteratorOfListIO It(selected);
1765 for ( ; It.More(); It.Next())
1767 Handle(SALOME_InteractiveObject) IObject = It.Value();
1768 QString Type = CheckTypeObject(IObject);
1769 if (Type.compare(RefType) != 0)
1770 return "Heterogeneous Selection";
1776 uint randomize( uint size )
1778 static bool initialized = false;
1779 if ( !initialized ) {
1780 qsrand( QDateTime::currentDateTime().toTime_t() );
1784 v = uint( (double)( v ) / RAND_MAX * size );
1785 v = qMax( uint(0), qMin ( v, size-1 ) );
1791 void SMESHGUI::OnEditDelete()
1793 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1794 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1795 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1797 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1798 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1799 _PTR(GenericAttribute) anAttr;
1800 _PTR(AttributeIOR) anIOR;
1802 int objectCount = 0;
1804 QString aParentComponent = QString::null;
1805 Handle(SALOME_InteractiveObject) anIO;
1806 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1808 anIO = anIt.Value();
1809 QString cur = anIO->getComponentDataType();
1810 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1812 // check if object is reference
1813 _PTR(SObject) aRefSObj;
1814 aNameList.append("\n - ");
1815 if ( aSO->ReferencedObject( aRefSObj ) ) {
1816 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1817 aNameList.append( aRefName );
1818 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1821 aNameList.append(anIO->getName());
1825 if( aParentComponent.isNull() )
1826 aParentComponent = cur;
1827 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1828 aParentComponent = "";
1831 if ( objectCount == 0 )
1832 return; // No Valid Objects Selected
1834 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1835 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1836 QObject::tr("ERR_ERROR"),
1837 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1840 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1841 if (SUIT_MessageBox::warning
1842 (SMESHGUI::desktop(),
1843 QObject::tr("SMESH_WRN_WARNING"),
1844 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1845 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1846 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1849 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1851 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1852 // then treat them all starting from the deepest objects (at list back)
1853 std::list< _PTR(SObject) > listSO;
1854 SALOME_ListIteratorOfListIO It(selected);
1855 for( ; It.More(); It.Next()) // loop on selected IO's
1857 Handle(SALOME_InteractiveObject) IObject = It.Value();
1858 if(IObject->hasEntry()) {
1859 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1861 // disable removal of "SMESH" component object
1862 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1864 if ( engineIOR() == anIOR->Value().c_str() )
1867 //Check the referenced object
1868 _PTR(SObject) aRefSObject;
1869 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1870 aSO = aRefSObject; // Delete main Object instead of reference
1872 listSO.push_back( aSO );
1873 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1874 for ( ; itSO != listSO.end(); ++itSO ) {
1875 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1876 for (it->InitEx(false); it->More(); it->Next())
1877 listSO.push_back( it->Value() );
1881 // Check if none of objects to delete is referred from outside
1882 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1883 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1885 _PTR(SObject) SO = *ritSO;
1886 if ( !SO ) continue;
1887 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1888 for (size_t i = 0; i < aReferences.size(); i++) {
1889 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1890 std::string type = aComponent->ComponentDataType();
1891 if ( type != "SMESH" )
1893 SUIT_MessageBox::warning( anApp->desktop(),
1894 QObject::tr("WRN_WARNING"),
1895 QObject::tr("DEP_OBJECT") );
1896 return; // outside SMESH, there is an object depending on a SMESH object
1901 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1902 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1904 Handle(SALOME_InteractiveObject) IObject = It.Value();
1905 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1906 if ( !mesh->_is_nil() )
1910 // Treat SO's in the list starting from the back
1911 aStudyBuilder->NewCommand(); // There is a transaction
1912 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1914 _PTR(SObject) SO = *ritSO;
1915 if ( !SO ) continue;
1916 std::string anEntry = SO->GetID();
1918 /** Erase graphical object and remove all its data **/
1919 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1920 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1922 /** Remove an object from data structures **/
1923 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1924 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1925 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1926 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1927 aMesh->RemoveGroup( aGroup );
1929 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1930 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1931 aMesh->RemoveSubMesh( aSubMesh );
1933 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1935 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1938 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1939 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1940 QString objType = CheckTypeObject(IObject);
1941 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1942 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1943 aStudyBuilder->RemoveObjectWithChildren( SO );
1945 else {// default action: remove SObject from the study
1946 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1947 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1949 aStudyBuilder->RemoveObjectWithChildren( SO );
1953 } /* listSO back loop */
1955 aStudyBuilder->CommitCommand();
1957 /* Clear any previous selection */
1959 aSel->setSelectedObjects( l1 );
1961 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1965 SMESHGUI_EXPORT CAM_Module* createModule()
1967 return new SMESHGUI();
1970 SMESHGUI_EXPORT char* getModuleVersion() {
1971 return (char*)SMESH_VERSION_STR;
1975 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1977 //=============================================================================
1981 //=============================================================================
1982 SMESHGUI::SMESHGUI() :
1983 SalomeApp_Module( "SMESH" )
1985 if ( CORBA::is_nil( myComponentSMESH ) )
1987 CORBA::Boolean anIsEmbeddedMode;
1988 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1989 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1991 // 0019923: EDF 765 SMESH : default values of hypothesis
1992 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1993 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1994 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1995 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1996 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1998 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1999 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2000 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2002 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2003 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2007 myActiveDialogBox = 0;
2008 myFilterLibraryDlg = 0;
2012 myEventCallbackCommand = vtkCallbackCommand::New();
2013 myEventCallbackCommand->Delete();
2014 myEventCallbackCommand->SetClientData( this );
2015 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2018 /* load resources for all available meshers */
2019 SMESH::InitAvailableHypotheses();
2022 //=============================================================================
2026 //=============================================================================
2027 SMESHGUI::~SMESHGUI()
2031 //=============================================================================
2035 //=============================================================================
2036 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2038 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2040 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2045 //=============================================================================
2049 //=============================================================================
2050 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2052 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2056 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2057 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2058 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2059 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2060 return autoUpdate && !exceeded;
2063 //=============================================================================
2067 //=============================================================================
2068 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2069 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2071 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2075 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2076 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2077 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2079 SMESH::long_array_var info = theMesh->GetMeshInfo();
2080 long nbOdElems = info[SMDSEntity_0D];
2081 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2082 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2083 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2084 info[SMDSEntity_Polygon];
2085 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2086 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2087 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2088 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2089 info[SMDSEntity_Polyhedra] +
2090 info[SMDSEntity_Hexagonal_Prism];
2091 long nbBalls = info[SMDSEntity_Ball];
2093 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2094 *nbElements = requestedSize;
2096 *entities = SMESH_Actor::eAllEntity;
2099 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2101 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2103 if ( incrementalLimit ) {
2106 if ( nbOdElems > 0 ) {
2107 if ( total + nbOdElems > updateLimit ) {
2108 *entities = *entities & ~SMESH_Actor::e0DElements;
2109 *hidden = *hidden | SMESH_Actor::e0DElements;
2116 if ( nbEdges > 0 ) {
2117 if ( total + nbEdges > updateLimit ) {
2118 *entities = *entities & ~SMESH_Actor::eEdges;
2119 *hidden = *hidden | SMESH_Actor::eEdges;
2126 if ( nbFaces > 0 ) {
2127 if ( total + nbFaces > updateLimit ) {
2128 *entities = *entities & ~SMESH_Actor::eFaces;
2129 *hidden = *hidden | SMESH_Actor::eFaces;
2136 if ( nbVolumes > 0 ) {
2137 if ( total + nbVolumes > updateLimit ) {
2138 *entities = *entities & ~SMESH_Actor::eVolumes;
2139 *hidden = *hidden | SMESH_Actor::eVolumes;
2146 if ( nbBalls > 0 ) {
2147 if ( total + nbBalls > updateLimit ) {
2148 *entities = *entities & ~SMESH_Actor::eBallElem;
2149 *hidden = *hidden | SMESH_Actor::eBallElem;
2157 return autoUpdate && !exceeded;
2160 //=============================================================================
2164 //=============================================================================
2165 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2167 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2170 //=============================================================================
2174 //=============================================================================
2175 SMESHGUI* SMESHGUI::GetSMESHGUI()
2177 SMESHGUI* smeshMod = 0;
2178 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2181 CAM_Module* module = app->module( "Mesh" );
2182 smeshMod = dynamic_cast<SMESHGUI*>( module );
2185 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2187 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2190 _PTR(Study) aStudy = study->studyDS();
2192 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2201 Standard_EXPORT SMESHGUI* GetComponentGUI()
2203 return SMESHGUI::GetSMESHGUI();
2207 //=============================================================================
2211 //=============================================================================
2212 void SMESHGUI::SetState(int aState)
2217 //=============================================================================
2221 //=============================================================================
2222 void SMESHGUI::ResetState()
2227 //=============================================================================
2231 //=============================================================================
2232 void SMESHGUI::EmitSignalDeactivateDialog()
2234 emit SignalDeactivateActiveDialog();
2237 //=============================================================================
2241 //=============================================================================
2242 void SMESHGUI::EmitSignalStudyFrameChanged()
2244 emit SignalStudyFrameChanged();
2247 //=============================================================================
2251 //=============================================================================
2252 void SMESHGUI::EmitSignalCloseAllDialogs()
2254 emit SignalCloseAllDialogs();
2257 //=============================================================================
2261 //=============================================================================
2262 void SMESHGUI::EmitSignalVisibilityChanged()
2264 emit SignalVisibilityChanged();
2267 //=============================================================================
2271 //=============================================================================
2272 void SMESHGUI::EmitSignalCloseView()
2274 emit SignalCloseView();
2277 //=============================================================================
2281 //=============================================================================
2282 void SMESHGUI::EmitSignalActivatedViewManager()
2284 emit SignalActivatedViewManager();
2287 //=============================================================================
2291 //=============================================================================
2292 QDialog *SMESHGUI::GetActiveDialogBox()
2294 return myActiveDialogBox;
2297 //=============================================================================
2301 //=============================================================================
2302 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2304 myActiveDialogBox = (QDialog *) aDlg;
2308 //=============================================================================
2312 //=============================================================================
2313 SUIT_Desktop* SMESHGUI::desktop()
2315 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2317 return app->desktop();
2322 //=============================================================================
2326 //=============================================================================
2327 SalomeApp_Study* SMESHGUI::activeStudy()
2329 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2331 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2336 //=============================================================================
2340 //=============================================================================
2341 void SMESHGUI::Modified( bool theIsUpdateActions )
2343 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2344 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2345 appStudy->Modified();
2346 if( theIsUpdateActions )
2347 app->updateActions();
2352 //=============================================================================
2356 //=============================================================================
2357 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2359 /* Here the position is on the bottom right corner - 10 */
2360 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2362 SUIT_Desktop *PP = desktop();
2363 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2364 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2368 //=============================================================================
2372 //=============================================================================
2373 static int isStudyLocked(_PTR(Study) theStudy){
2374 return theStudy->GetProperties()->IsLocked();
2377 static bool checkLock(_PTR(Study) theStudy) {
2378 if (isStudyLocked(theStudy)) {
2379 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2380 QObject::tr("WRN_WARNING"),
2381 QObject::tr("WRN_STUDY_LOCKED") );
2387 //=======================================================================
2388 //function : CheckActiveStudyLocked
2390 //=======================================================================
2392 bool SMESHGUI::isActiveStudyLocked()
2394 _PTR(Study) aStudy = activeStudy()->studyDS();
2395 return checkLock( aStudy );
2398 //=============================================================================
2402 //=============================================================================
2403 bool SMESHGUI::OnGUIEvent( int theCommandID )
2405 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2409 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2410 SUIT_ResourceMgr* mgr = resourceMgr();
2414 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2415 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2418 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2419 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2421 //QAction* act = action( theCommandID );
2423 switch (theCommandID) {
2424 case SMESHOp::OpDelete:
2425 if(checkLock(aStudy)) break;
2428 case SMESHOp::OpImportDAT:
2429 case SMESHOp::OpImportUNV:
2430 case SMESHOp::OpImportMED:
2431 case SMESHOp::OpImportSTL:
2433 case SMESHOp::OpImportCGNS:
2435 case SMESHOp::OpImportSAUV:
2436 case SMESHOp::OpImportGMF:
2438 if(checkLock(aStudy)) break;
2439 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2443 case SMESHOp::OpFileInformation:
2445 SALOME_ListIO selected;
2446 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2448 aSel->selectedObjects( selected );
2449 if( selected.Extent() )
2451 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2452 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2453 if ( !aMesh->_is_nil() )
2455 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2461 case SMESHOp::OpExportDAT:
2462 case SMESHOp::OpExportMED:
2463 case SMESHOp::OpExportUNV:
2464 case SMESHOp::OpExportSTL:
2466 case SMESHOp::OpExportCGNS:
2468 case SMESHOp::OpExportSAUV:
2469 case SMESHOp::OpExportGMF:
2470 case SMESHOp::OpPopupExportDAT:
2471 case SMESHOp::OpPopupExportMED:
2472 case SMESHOp::OpPopupExportUNV:
2473 case SMESHOp::OpPopupExportSTL:
2475 case SMESHOp::OpPopupExportCGNS:
2477 case SMESHOp::OpPopupExportSAUV:
2478 case SMESHOp::OpPopupExportGMF:
2480 ::ExportMeshToFile(theCommandID);
2484 case SMESHOp::OpReset: // SCALAR BAR
2486 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2487 SALOME_ListIO selected;
2489 aSel->selectedObjects( selected );
2491 if( selected.Extent() ) {
2492 Handle(SALOME_InteractiveObject) anIO = selected.First();
2493 if( anIO->hasEntry() ) {
2494 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2495 anActor->SetControlMode( SMESH_Actor::eNone );
2496 #ifndef DISABLE_PLOT2DVIEWER
2497 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2504 case SMESHOp::OpScalarBarProperties:
2506 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2509 case SMESHOp::OpShowScalarBar:
2511 // show/hide scalar bar
2512 ::ShowElement(theCommandID);
2515 case SMESHOp::OpSaveDistribution:
2517 // dump control distribution data to the text file
2518 ::SaveDistribution();
2522 case SMESHOp::OpShowDistribution:
2524 // show/hide distribution
2525 ::ShowElement(theCommandID);
2529 #ifndef DISABLE_PLOT2DVIEWER
2530 case SMESHOp::OpPlotDistribution:
2532 // plot distribution
2533 ::PlotDistribution();
2539 case SMESHOp::OpAutoColor:
2543 case SMESHOp::OpDisableAutoColor:
2544 ::DisableAutoColor();
2547 case SMESHOp::OpClipping:
2548 case SMESHOp::OpTransparency:
2549 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2552 case SMESHOp::OpDMWireframe:
2553 case SMESHOp::OpDMShading:
2554 case SMESHOp::OpDMNodes:
2555 case SMESHOp::OpDMShrink:
2556 ::SetDisplayMode(theCommandID, myMarkerMap);
2559 //2D quadratic representation
2560 case SMESHOp::OpRepresentationLines:
2561 case SMESHOp::OpRepresentationArcs:
2562 ::SetDisplayMode(theCommandID, myMarkerMap);
2566 case SMESHOp::OpDE0DElements:
2567 case SMESHOp::OpDEEdges:
2568 case SMESHOp::OpDEFaces:
2569 case SMESHOp::OpDEVolumes:
2570 case SMESHOp::OpDEBalls:
2571 case SMESHOp::OpDEAllEntity:
2572 ::SetDisplayEntity(theCommandID);
2575 // Choose entities to be displayed
2576 case SMESHOp::OpDEChoose:
2578 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2582 case SMESHOp::OpOrientationOnFaces:
2584 LightApp_SelectionMgr* mgr = selectionMgr();
2585 SALOME_ListIO selected; mgr->selectedObjects( selected );
2587 SALOME_ListIteratorOfListIO it(selected);
2588 for( ; it.More(); it.Next()) {
2589 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2590 if(anIObject->hasEntry()) {
2591 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2592 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2599 case SMESHOp::OpUpdate:
2601 if(checkLock(aStudy)) break;
2602 SUIT_OverrideCursor wc;
2604 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2607 SMESH::UpdateView();
2609 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2610 SMESH::OnVisuException();
2612 catch (...) { // PAL16774 (Crash after display of many groups)
2613 SMESH::OnVisuException();
2617 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2618 aSel->selectedObjects( l );
2619 aSel->setSelectedObjects( l );
2623 case SMESHOp::OpHide:
2624 case SMESHOp::OpShow:
2625 case SMESHOp::OpShowOnly:
2627 SMESH::EDisplaing anAction;
2628 switch (theCommandID) {
2629 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2630 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2631 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2634 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2635 SALOME_ListIO sel_objects, to_process;
2637 aSel->selectedObjects( sel_objects );
2639 if( theCommandID==SMESHOp::OpShowOnly )
2641 MESSAGE("anAction = SMESH::eDisplayOnly");
2642 startOperation( myEraseAll );
2645 extractContainers( sel_objects, to_process );
2648 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2652 SALOME_ListIteratorOfListIO It( to_process );
2653 for ( ; It.More(); It.Next()) {
2655 Handle(SALOME_InteractiveObject) IOS = It.Value();
2656 if (IOS->hasEntry()) {
2658 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2659 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2660 break; // PAL16774 (Crash after display of many groups)
2662 if (anAction == SMESH::eDisplayOnly)
2664 MESSAGE("anAction = SMESH::eDisplayOnly");
2665 anAction = SMESH::eDisplay;
2671 // PAL13338 + PAL15161 -->
2672 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2673 MESSAGE("anAction = SMESH::eDisplayOnly");
2674 SMESH::UpdateView();
2675 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2677 // PAL13338 + PAL15161 <--
2679 catch (...) { // PAL16774 (Crash after display of many groups)
2680 SMESH::OnVisuException();
2683 if (anAction == SMESH::eErase) {
2684 MESSAGE("anAction == SMESH::eErase");
2686 aSel->setSelectedObjects( l1 );
2689 aSel->setSelectedObjects( to_process );
2694 case SMESHOp::OpNode:
2696 if(checkLock(aStudy)) break;
2699 EmitSignalDeactivateDialog();
2701 ( new SMESHGUI_NodesDlg( this ) )->show();
2704 SUIT_MessageBox::warning(desktop(),
2705 tr("SMESH_WRN_WARNING"),
2706 tr("SMESH_WRN_VIEWER_VTK"));
2711 case SMESHOp::OpCreateMesh:
2712 case SMESHOp::OpCreateSubMesh:
2713 case SMESHOp::OpEditMeshOrSubMesh:
2714 case SMESHOp::OpCompute:
2715 case SMESHOp::OpPreCompute:
2716 case SMESHOp::OpEvaluate:
2717 case SMESHOp::OpMeshOrder:
2718 startOperation( theCommandID );
2720 case SMESHOp::OpCopyMesh:
2722 if (checkLock(aStudy)) break;
2723 EmitSignalDeactivateDialog();
2724 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2727 case SMESHOp::OpBuildCompoundMesh:
2729 if (checkLock(aStudy)) break;
2730 EmitSignalDeactivateDialog();
2731 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2735 case SMESHOp::OpDiagonalInversion:
2736 case SMESHOp::OpUnionOfTwoTriangle:
2740 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2741 tr( "NOT_A_VTK_VIEWER" ) );
2745 if ( checkLock( aStudy ) )
2748 /*Standard_Boolean aRes;
2749 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2750 if ( aMesh->_is_nil() )
2752 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2753 tr( "SMESH_BAD_SELECTION" ) );
2757 EmitSignalDeactivateDialog();
2758 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2759 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2761 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2764 case SMESHOp::OpOrientation:
2765 case SMESHOp::OpUnionOfTriangles:
2766 case SMESHOp::OpCuttingOfQuadrangles:
2767 case SMESHOp::OpSplitVolumes:
2771 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2772 tr( "NOT_A_VTK_VIEWER" ) );
2776 if ( checkLock( aStudy ) )
2779 EmitSignalDeactivateDialog();
2780 SMESHGUI_MultiEditDlg* aDlg = NULL;
2781 if ( theCommandID == SMESHOp::OpOrientation )
2782 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2783 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2784 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2785 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2786 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2788 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2793 case SMESHOp::OpSmoothing:
2795 if(checkLock(aStudy)) break;
2797 EmitSignalDeactivateDialog();
2798 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2801 SUIT_MessageBox::warning(desktop(),
2802 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2806 case SMESHOp::OpExtrusion:
2808 if (checkLock(aStudy)) break;
2810 EmitSignalDeactivateDialog();
2811 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2813 SUIT_MessageBox::warning(desktop(),
2814 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2818 case SMESHOp::OpExtrusionAlongAPath:
2820 if (checkLock(aStudy)) break;
2822 EmitSignalDeactivateDialog();
2823 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2825 SUIT_MessageBox::warning(desktop(),
2826 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2830 case SMESHOp::OpRevolution:
2832 if(checkLock(aStudy)) break;
2834 EmitSignalDeactivateDialog();
2835 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2838 SUIT_MessageBox::warning(desktop(),
2839 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2843 case SMESHOp::OpPatternMapping:
2845 if ( checkLock( aStudy ) )
2849 EmitSignalDeactivateDialog();
2850 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2853 SUIT_MessageBox::warning(desktop(),
2854 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2858 case SMESHOp::OpConvertMeshToQuadratic:
2859 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2860 case SMESHOp::OpReorientFaces:
2861 case SMESHOp::OpCreateGeometryGroup:
2863 startOperation( theCommandID );
2866 case SMESHOp::OpCreateGroup:
2870 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2871 tr( "NOT_A_VTK_VIEWER" ) );
2875 if(checkLock(aStudy)) break;
2876 EmitSignalDeactivateDialog();
2877 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2879 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2880 SALOME_ListIO selected;
2882 aSel->selectedObjects( selected );
2884 int nbSel = selected.Extent();
2886 // check if mesh is selected
2887 aMesh = SMESH::GetMeshByIO( selected.First() );
2889 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2894 case SMESHOp::OpConstructGroup:
2898 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2899 tr( "NOT_A_VTK_VIEWER" ) );
2903 if(checkLock(aStudy)) break;
2904 EmitSignalDeactivateDialog();
2906 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2907 SALOME_ListIO selected;
2909 aSel->selectedObjects( selected );
2911 int nbSel = selected.Extent();
2913 // check if submesh is selected
2914 Handle(SALOME_InteractiveObject) IObject = selected.First();
2915 if (IObject->hasEntry()) {
2916 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2918 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2919 if (!aSubMesh->_is_nil()) {
2921 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2922 // get submesh elements list by types
2923 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2924 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2925 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2926 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2927 // create group for each type o elements
2928 QString aName = IObject->getName();
2929 QStringList anEntryList;
2930 if (aNodes->length() > 0) {
2931 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2932 aGroup->Add(aNodes.inout());
2933 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2934 anEntryList.append( aSObject->GetID().c_str() );
2936 if (aEdges->length() > 0) {
2937 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2938 aGroup->Add(aEdges.inout());
2939 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2940 anEntryList.append( aSObject->GetID().c_str() );
2942 if (aFaces->length() > 0) {
2943 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2944 aGroup->Add(aFaces.inout());
2945 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2946 anEntryList.append( aSObject->GetID().c_str() );
2948 if (aVolumes->length() > 0) {
2949 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2950 aGroup->Add(aVolumes.inout());
2951 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2952 anEntryList.append( aSObject->GetID().c_str() );
2955 anApp->browseObjects( anEntryList );
2957 catch(const SALOME::SALOME_Exception & S_ex){
2958 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2965 SUIT_MessageBox::warning(desktop(),
2966 tr("SMESH_WRN_WARNING"),
2967 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2972 case SMESHOp::OpEditGroup:
2976 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2977 tr( "NOT_A_VTK_VIEWER" ) );
2981 if(checkLock(aStudy)) break;
2982 EmitSignalDeactivateDialog();
2984 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2985 SALOME_ListIO selected;
2987 aSel->selectedObjects( selected );
2989 SALOME_ListIteratorOfListIO It (selected);
2990 int nbSelectedGroups = 0;
2991 for ( ; It.More(); It.Next() )
2993 SMESH::SMESH_GroupBase_var aGroup =
2994 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2995 if (!aGroup->_is_nil()) {
2997 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3001 if (nbSelectedGroups == 0)
3003 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3009 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3011 if(checkLock(aStudy)) break;
3012 if (myState == 800) {
3013 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3014 if (aDlg) aDlg->onAdd();
3019 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3021 if(checkLock(aStudy)) break;
3022 if (myState == 800) {
3023 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3024 if (aDlg) aDlg->onRemove();
3029 case SMESHOp::OpEditGeomGroupAsGroup:
3033 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3034 tr( "NOT_A_VTK_VIEWER" ) );
3038 if(checkLock(aStudy)) break;
3039 EmitSignalDeactivateDialog();
3041 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3042 SALOME_ListIO selected;
3044 aSel->selectedObjects( selected );
3046 SALOME_ListIteratorOfListIO It (selected);
3047 for ( ; It.More(); It.Next() )
3049 SMESH::SMESH_GroupOnGeom_var aGroup =
3050 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3051 if (!aGroup->_is_nil()) {
3052 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3057 SMESH::SMESH_GroupOnFilter_var aGroup =
3058 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3059 if (!aGroup->_is_nil()) {
3060 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3068 case SMESHOp::OpUnionGroups:
3069 case SMESHOp::OpIntersectGroups:
3070 case SMESHOp::OpCutGroups:
3074 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3075 tr( "NOT_A_VTK_VIEWER" ) );
3079 if ( checkLock( aStudy ) )
3082 EmitSignalDeactivateDialog();
3084 SMESHGUI_GroupOpDlg* aDlg = 0;
3085 if ( theCommandID == SMESHOp::OpUnionGroups )
3086 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3087 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3088 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3090 aDlg = new SMESHGUI_CutGroupsDlg( this );
3097 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3099 if ( checkLock( aStudy ) )
3102 EmitSignalDeactivateDialog();
3103 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3109 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3113 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3114 tr( "NOT_A_VTK_VIEWER" ) );
3118 if ( checkLock( aStudy ) )
3121 EmitSignalDeactivateDialog();
3123 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3127 case SMESHOp::OpMeshInformation:
3128 case SMESHOp::OpWhatIs:
3130 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3131 EmitSignalDeactivateDialog();
3132 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3133 SALOME_ListIO selected;
3135 aSel->selectedObjects( selected );
3137 if ( selected.Extent() > 1 ) { // a dlg for each IO
3138 SALOME_ListIteratorOfListIO It( selected );
3139 for ( ; It.More(); It.Next() ) {
3140 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3141 dlg->showInfo( It.Value() );
3146 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3152 case SMESHOp::OpFindElementByPoint:
3154 startOperation( theCommandID );
3158 case SMESHOp::OpEditHypothesis:
3160 if(checkLock(aStudy)) break;
3162 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3163 SALOME_ListIO selected;
3165 aSel->selectedObjects( selected );
3167 int nbSel = selected.Extent();
3170 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3171 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3173 if ( !aHypothesis->_is_nil() )
3175 SMESHGUI_GenericHypothesisCreator* aCreator =
3176 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3179 // set geometry of mesh and sub-mesh to aCreator
3180 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3181 if ( selected.Extent() == 1 )
3183 QString subGeomID, meshGeomID;
3184 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3185 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3187 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3188 aCreator->setShapeEntry( subGeomID );
3189 aCreator->setMainShapeEntry( meshGeomID );
3193 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3203 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3205 if(checkLock(aStudy)) break;
3206 SUIT_OverrideCursor wc;
3208 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3209 SALOME_ListIO selected;
3211 aSel->selectedObjects( selected, QString::null, false );
3213 SALOME_ListIteratorOfListIO It(selected);
3214 for (int i = 0; It.More(); It.Next(), i++) {
3215 Handle(SALOME_InteractiveObject) IObject = It.Value();
3216 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3219 aSel->setSelectedObjects( l1 );
3224 case SMESHOp::OpElem0D:
3225 case SMESHOp::OpBall:
3226 case SMESHOp::OpEdge:
3227 case SMESHOp::OpTriangle:
3228 case SMESHOp::OpQuadrangle:
3229 case SMESHOp::OpPolygon:
3230 case SMESHOp::OpTetrahedron:
3231 case SMESHOp::OpHexahedron:
3232 case SMESHOp::OpPentahedron:
3233 case SMESHOp::OpPyramid:
3234 case SMESHOp::OpHexagonalPrism:
3236 if(checkLock(aStudy)) break;
3238 EmitSignalDeactivateDialog();
3239 SMDSAbs_EntityType type = SMDSEntity_Edge;
3240 switch (theCommandID) {
3241 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3242 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3243 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3244 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3245 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3246 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3247 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3248 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3249 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3250 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3253 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3256 SUIT_MessageBox::warning(desktop(),
3257 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3261 case SMESHOp::OpPolyhedron:
3263 if(checkLock(aStudy)) break;
3265 EmitSignalDeactivateDialog();
3266 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3269 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3270 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3274 case SMESHOp::OpQuadraticEdge:
3275 case SMESHOp::OpQuadraticTriangle:
3276 case SMESHOp::OpBiQuadraticTriangle:
3277 case SMESHOp::OpQuadraticQuadrangle:
3278 case SMESHOp::OpBiQuadraticQuadrangle:
3279 case SMESHOp::OpQuadraticTetrahedron:
3280 case SMESHOp::OpQuadraticPyramid:
3281 case SMESHOp::OpQuadraticPentahedron:
3282 case SMESHOp::OpQuadraticHexahedron:
3283 case SMESHOp::OpTriQuadraticHexahedron:
3285 if(checkLock(aStudy)) break;
3287 EmitSignalDeactivateDialog();
3288 SMDSAbs_EntityType type = SMDSEntity_Last;
3290 switch (theCommandID) {
3291 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3292 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3293 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3294 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3295 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3296 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3297 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3298 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3299 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3300 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3303 if ( type != SMDSEntity_Last )
3304 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3307 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3308 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3312 case SMESHOp::OpRemoveNodes:
3314 if(checkLock(aStudy)) break;
3316 EmitSignalDeactivateDialog();
3317 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3320 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3321 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3325 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3327 if(checkLock(aStudy)) break;
3329 EmitSignalDeactivateDialog();
3330 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3334 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3335 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3339 case SMESHOp::OpClearMesh: {
3341 if(checkLock(aStudy)) break;
3343 SALOME_ListIO selected;
3344 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3345 aSel->selectedObjects( selected );
3347 SUIT_OverrideCursor wc;
3348 SALOME_ListIteratorOfListIO It (selected);
3349 for ( ; It.More(); It.Next() )
3351 Handle(SALOME_InteractiveObject) IOS = It.Value();
3352 SMESH::SMESH_Mesh_var aMesh =
3353 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3354 if ( aMesh->_is_nil()) continue;
3356 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3358 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3359 SMESH::ModifiedMesh( aMeshSObj, false, true);
3360 // hide groups and submeshes
3361 _PTR(ChildIterator) anIter =
3362 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3363 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3365 _PTR(SObject) so = anIter->Value();
3366 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3369 catch (const SALOME::SALOME_Exception& S_ex){
3371 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3375 SMESH::UpdateView();
3379 case SMESHOp::OpRemoveOrphanNodes:
3381 if(checkLock(aStudy)) break;
3382 SALOME_ListIO selected;
3383 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3384 aSel->selectedObjects( selected );
3385 if ( selected.Extent() == 1 ) {
3386 Handle(SALOME_InteractiveObject) anIO = selected.First();
3387 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3388 if ( !aMesh->_is_nil() ) {
3389 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3390 tr( "SMESH_WARNING" ),
3391 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3392 SUIT_MessageBox::Yes |
3393 SUIT_MessageBox::No,
3394 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3397 SUIT_OverrideCursor wc;
3398 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3399 int removed = aMeshEditor->RemoveOrphanNodes();
3400 SUIT_MessageBox::information(SMESHGUI::desktop(),
3401 tr("SMESH_INFORMATION"),
3402 tr("NB_NODES_REMOVED").arg(removed));
3403 if ( removed > 0 ) {
3404 SMESH::UpdateView();
3405 SMESHGUI::Modified();
3408 catch (const SALOME::SALOME_Exception& S_ex) {
3409 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3418 case SMESHOp::OpRenumberingNodes:
3420 if(checkLock(aStudy)) break;
3422 EmitSignalDeactivateDialog();
3423 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3427 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3428 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3432 case SMESHOp::OpRenumberingElements:
3434 if(checkLock(aStudy)) break;
3436 EmitSignalDeactivateDialog();
3437 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3441 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3442 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3446 case SMESHOp::OpTranslation:
3448 if(checkLock(aStudy)) break;
3450 EmitSignalDeactivateDialog();
3451 ( new SMESHGUI_TranslationDlg( this ) )->show();
3454 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3455 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3459 case SMESHOp::OpRotation:
3461 if(checkLock(aStudy)) break;
3463 EmitSignalDeactivateDialog();
3464 ( new SMESHGUI_RotationDlg( this ) )->show();
3467 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3468 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3472 case SMESHOp::OpSymmetry:
3474 if(checkLock(aStudy)) break;
3476 EmitSignalDeactivateDialog();
3477 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3480 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3481 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3485 case SMESHOp::OpScale:
3487 if(checkLock(aStudy)) break;
3489 EmitSignalDeactivateDialog();
3490 ( new SMESHGUI_ScaleDlg( this ) )->show();
3493 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3494 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3499 case SMESHOp::OpSewing:
3501 if(checkLock(aStudy)) break;
3503 EmitSignalDeactivateDialog();
3504 ( new SMESHGUI_SewingDlg( this ) )->show();
3507 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3508 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3512 case SMESHOp::OpMergeNodes:
3514 if(checkLock(aStudy)) break;
3516 EmitSignalDeactivateDialog();
3517 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3520 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3521 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3525 case SMESHOp::OpMergeElements:
3527 if (checkLock(aStudy)) break;
3529 EmitSignalDeactivateDialog();
3530 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3532 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3533 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3538 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3539 startOperation( SMESHOp::OpMoveNode );
3542 case SMESHOp::OpDuplicateNodes:
3544 if(checkLock(aStudy)) break;
3546 EmitSignalDeactivateDialog();
3547 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3550 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3556 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3557 startOperation( SMESHOp::OpElem0DOnElemNodes );
3560 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3562 static QList<int> aTypes;
3563 if ( aTypes.isEmpty() )
3565 aTypes.append( SMESH::NODE );
3566 aTypes.append( SMESH::EDGE );
3567 aTypes.append( SMESH::FACE );
3568 aTypes.append( SMESH::VOLUME );
3570 if (!myFilterLibraryDlg)
3571 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3572 else if (myFilterLibraryDlg->isHidden())
3573 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3574 myFilterLibraryDlg->raise();
3578 case SMESHOp::OpFreeNode:
3579 case SMESHOp::OpEqualNode:
3580 case SMESHOp::OpFreeEdge:
3581 case SMESHOp::OpFreeBorder:
3582 case SMESHOp::OpLength:
3583 case SMESHOp::OpConnection:
3584 case SMESHOp::OpEqualEdge:
3585 case SMESHOp::OpFreeFace:
3586 case SMESHOp::OpBareBorderFace:
3587 case SMESHOp::OpOverConstrainedFace:
3588 case SMESHOp::OpLength2D:
3589 case SMESHOp::OpConnection2D:
3590 case SMESHOp::OpArea:
3591 case SMESHOp::OpTaper:
3592 case SMESHOp::OpAspectRatio:
3593 case SMESHOp::OpMinimumAngle:
3594 case SMESHOp::OpWarpingAngle:
3595 case SMESHOp::OpSkew:
3596 case SMESHOp::OpMaxElementLength2D:
3597 case SMESHOp::OpEqualFace:
3598 case SMESHOp::OpAspectRatio3D:
3599 case SMESHOp::OpVolume:
3600 case SMESHOp::OpMaxElementLength3D:
3601 case SMESHOp::OpBareBorderVolume:
3602 case SMESHOp::OpOverConstrainedVolume:
3603 case SMESHOp::OpEqualVolume:
3606 LightApp_SelectionMgr* mgr = selectionMgr();
3607 SALOME_ListIO selected; mgr->selectedObjects( selected );
3609 if( !selected.IsEmpty() ) {
3610 SUIT_OverrideCursor wc;
3611 ::Control( theCommandID );
3614 SUIT_MessageBox::warning(desktop(),
3615 tr( "SMESH_WRN_WARNING" ),
3616 tr( "SMESH_BAD_SELECTION" ) );
3620 SUIT_MessageBox::warning(desktop(),
3621 tr( "SMESH_WRN_WARNING" ),
3622 tr( "NOT_A_VTK_VIEWER" ) );
3625 case SMESHOp::OpOverallMeshQuality:
3626 OverallMeshQuality();
3628 case SMESHOp::OpNumberingNodes:
3630 SUIT_OverrideCursor wc;
3631 LightApp_SelectionMgr* mgr = selectionMgr();
3632 SALOME_ListIO selected; mgr->selectedObjects( selected );
3634 SALOME_ListIteratorOfListIO it(selected);
3635 for( ; it.More(); it.Next()) {
3636 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3637 if(anIObject->hasEntry()) {
3638 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3639 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3645 case SMESHOp::OpNumberingElements:
3647 SUIT_OverrideCursor wc;
3648 LightApp_SelectionMgr* mgr = selectionMgr();
3649 SALOME_ListIO selected; mgr->selectedObjects( selected );
3651 SALOME_ListIteratorOfListIO it(selected);
3652 for( ; it.More(); it.Next()) {
3653 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3654 if(anIObject->hasEntry())
3655 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3656 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3661 case SMESHOp::OpPropertiesLength:
3662 case SMESHOp::OpPropertiesArea:
3663 case SMESHOp::OpPropertiesVolume:
3664 case SMESHOp::OpMinimumDistance:
3665 case SMESHOp::OpBoundingBox:
3667 int page = SMESHGUI_MeasureDlg::MinDistance;
3668 if ( theCommandID == SMESHOp::OpBoundingBox )
3669 page = SMESHGUI_MeasureDlg::BoundingBox;
3670 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3671 page = SMESHGUI_MeasureDlg::Length;
3672 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3673 page = SMESHGUI_MeasureDlg::Area;
3674 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3675 page = SMESHGUI_MeasureDlg::Volume;
3677 EmitSignalDeactivateDialog();
3678 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3682 case SMESHOp::OpSortChild:
3688 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3689 //updateObjBrowser();
3693 //=============================================================================
3697 //=============================================================================
3698 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3703 //=============================================================================
3707 //=============================================================================
3708 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3713 //=============================================================================
3717 //=============================================================================
3718 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3723 //=============================================================================
3724 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3725 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3727 //=============================================================================
3728 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3729 SUIT_ViewWindow* wnd )
3731 if(theIO->hasEntry()){
3732 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3733 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3737 //=======================================================================
3738 // function : createSMESHAction
3740 //=======================================================================
3741 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3742 const int key, const bool toggle, const QString& shortcutAction )
3745 QWidget* parent = application()->desktop();
3746 SUIT_ResourceMgr* resMgr = resourceMgr();
3748 if ( !icon_id.isEmpty() )
3749 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3751 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3752 if ( !pix.isNull() )
3753 icon = QIcon( pix );
3755 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3756 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3757 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3759 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3760 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3763 //=======================================================================
3764 // function : createPopupItem
3766 //=======================================================================
3767 void SMESHGUI::createPopupItem( const int id,
3768 const QString& clients,
3769 const QString& types,
3770 const QString& theRule,
3773 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3774 popupMgr()->insert( action( id ), pId, 0 );
3776 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3777 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3778 QString rule = "(%1) and (%2) and (%3)";
3779 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3780 if( clients.isEmpty() )
3781 rule = rule.arg( QString( "true" ) );
3783 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3784 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3787 bool cont = myRules.contains( id );
3789 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3791 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3792 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3795 //=======================================================================
3796 // function : initialize
3798 //=======================================================================
3799 void SMESHGUI::initialize( CAM_Application* app )
3801 SalomeApp_Module::initialize( app );
3803 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3805 /* Automatic Update flag */
3806 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3808 // ----- create actions --------------
3810 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3811 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3812 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3813 //createSMESHAction( 114, "NUM" );
3814 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3816 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3818 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3819 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3820 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3821 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3822 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3823 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3825 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3827 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3828 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3829 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3830 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3831 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3832 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3834 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3836 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3837 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3838 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3839 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3840 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3841 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3842 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3843 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3844 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3845 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3846 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3847 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3848 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3849 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3850 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3851 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3852 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3853 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3854 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3855 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3856 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3857 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3858 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3859 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3860 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3861 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3862 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3863 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3864 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3865 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3867 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3868 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3869 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3870 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3871 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3872 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3873 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3874 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3875 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3876 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3877 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3878 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3879 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3880 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3881 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3882 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3883 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3884 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3885 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3886 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3887 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3888 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3889 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3890 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3891 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3892 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3893 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3895 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3896 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3897 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3898 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3899 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3900 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3901 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3902 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3903 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3904 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3905 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3906 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3907 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3908 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3909 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3910 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3911 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3912 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3913 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3914 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3915 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3916 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3917 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3918 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3920 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3921 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3922 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3923 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3925 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3926 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3928 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3929 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3930 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3931 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3932 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3933 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3934 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3935 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3936 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3937 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3938 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3939 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3940 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3941 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3942 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3943 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3944 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3945 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3946 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3947 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3948 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3949 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3950 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3952 createSMESHAction( SMESHOp::OpReset, "RESET" );
3953 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3954 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3955 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3956 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3957 #ifndef DISABLE_PLOT2DVIEWER
3958 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3960 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3961 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3962 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3963 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3964 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3965 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3966 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3967 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3968 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3969 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3970 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3971 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3972 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3974 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3975 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3977 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3978 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3979 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3980 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3981 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3982 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3983 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3984 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3985 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3987 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3988 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3989 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3990 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3991 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3993 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3994 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3995 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3997 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3999 QList<int> aCtrlActions;
4000 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
4001 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4002 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4003 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4004 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4005 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4006 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4007 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4008 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4009 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4010 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4011 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4012 aCtrlGroup->setExclusive( true );
4013 for( int i = 0; i < aCtrlActions.size(); i++ )
4014 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4016 // ----- create menu --------------
4017 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4018 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4019 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4020 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4021 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4022 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4023 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4024 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4026 createMenu( separator(), fileId );
4028 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4029 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4030 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
4031 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
4032 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
4033 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
4034 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4035 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4036 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4037 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4038 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4040 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4041 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4042 createMenu( SMESHOp::OpImportMED, importId, -1 );
4043 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4045 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4047 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4048 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4049 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4050 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4051 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4052 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4054 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4056 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4057 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4058 createMenu( separator(), fileId, 10 );
4060 createMenu( SMESHOp::OpDelete, editId, -1 );
4062 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4064 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4065 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4066 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4067 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4068 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4069 createMenu( separator(), meshId, -1 );
4070 createMenu( SMESHOp::OpCompute, meshId, -1 );
4071 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4072 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4073 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4074 createMenu( separator(), meshId, -1 );
4075 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4076 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4077 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4078 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4079 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4080 createMenu( separator(), meshId, -1 );
4081 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4082 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4083 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4084 createMenu( separator(), meshId, -1 );
4085 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4086 createMenu( separator(), meshId, -1 );
4087 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4088 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4089 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4090 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4091 createMenu( separator(), meshId, -1 );
4093 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4094 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4095 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4096 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4097 createMenu( SMESHOp::OpLength, edgeId, -1 );
4098 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4099 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4100 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4101 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4102 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4103 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4104 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4105 createMenu( SMESHOp::OpArea, faceId, -1 );
4106 createMenu( SMESHOp::OpTaper, faceId, -1 );
4107 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4108 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4109 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4110 createMenu( SMESHOp::OpSkew, faceId, -1 );
4111 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4112 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4113 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4114 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4115 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4116 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4117 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4118 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4119 createMenu( separator(), ctrlId, -1 );
4120 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4121 createMenu( separator(), ctrlId, -1 );
4122 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4124 createMenu( SMESHOp::OpNode, addId, -1 );
4125 createMenu( SMESHOp::OpElem0D, addId, -1 );
4126 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4127 createMenu( SMESHOp::OpBall, addId, -1 );
4128 createMenu( SMESHOp::OpEdge, addId, -1 );
4129 createMenu( SMESHOp::OpTriangle, addId, -1 );
4130 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4131 createMenu( SMESHOp::OpPolygon, addId, -1 );
4132 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4133 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4134 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4135 createMenu( SMESHOp::OpPyramid, addId, -1 );
4136 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4137 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4138 createMenu( separator(), addId, -1 );
4139 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4140 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4141 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4142 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4143 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4144 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4145 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4146 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4147 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4148 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4150 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4151 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4152 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4153 createMenu( separator(), removeId, -1 );
4154 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4155 createMenu( separator(), removeId, -1 );
4156 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4158 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4159 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4161 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4162 createMenu( SMESHOp::OpRotation, transfId, -1 );
4163 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4164 createMenu( SMESHOp::OpScale, transfId, -1 );
4165 createMenu( SMESHOp::OpSewing, transfId, -1 );
4166 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4167 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4168 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4170 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4171 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4172 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4173 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4174 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4175 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4176 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4177 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4178 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4179 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4180 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4181 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4182 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4183 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4184 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4186 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4187 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4188 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4189 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4190 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4191 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4193 // ----- create toolbars --------------
4194 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4195 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4196 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4197 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4198 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4199 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4200 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4201 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4202 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4203 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4204 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4205 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4206 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4207 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4208 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4210 createTool( SMESHOp::OpCreateMesh, meshTb );
4211 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4212 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4213 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4214 createTool( SMESHOp::OpCopyMesh, meshTb );
4215 createTool( separator(), meshTb );
4216 createTool( SMESHOp::OpCompute, meshTb );
4217 createTool( SMESHOp::OpPreCompute, meshTb );
4218 createTool( SMESHOp::OpEvaluate, meshTb );
4219 createTool( SMESHOp::OpMeshOrder, meshTb );
4221 createTool( SMESHOp::OpCreateGroup, groupTb );
4222 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4223 createTool( SMESHOp::OpConstructGroup, groupTb );
4224 createTool( SMESHOp::OpEditGroup, groupTb );
4226 createTool( SMESHOp::OpMeshInformation, info );
4227 //createTool( SMESHOp::OpStdInfo, meshTb );
4228 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4229 createTool( SMESHOp::OpFindElementByPoint, info );
4231 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4232 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4234 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4235 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4236 createTool( SMESHOp::OpLength, ctrl1dTb );
4237 createTool( SMESHOp::OpConnection, ctrl1dTb );
4238 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4240 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4241 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4242 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4243 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4244 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4245 createTool( SMESHOp::OpArea, ctrl2dTb );
4246 createTool( SMESHOp::OpTaper, ctrl2dTb );
4247 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4248 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4249 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4250 createTool( SMESHOp::OpSkew, ctrl2dTb );
4251 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4252 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4254 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4255 createTool( SMESHOp::OpVolume, ctrl3dTb );
4256 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4257 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4258 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4259 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4261 createTool( SMESHOp::OpNode, addElemTb );
4262 createTool( SMESHOp::OpElem0D, addElemTb );
4263 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4264 createTool( SMESHOp::OpBall, addElemTb );
4265 createTool( SMESHOp::OpEdge, addElemTb );
4266 createTool( SMESHOp::OpTriangle, addElemTb );
4267 createTool( SMESHOp::OpQuadrangle, addElemTb );
4268 createTool( SMESHOp::OpPolygon, addElemTb );
4269 createTool( SMESHOp::OpTetrahedron, addElemTb );
4270 createTool( SMESHOp::OpHexahedron, addElemTb );
4271 createTool( SMESHOp::OpPentahedron, addElemTb );
4272 createTool( SMESHOp::OpPyramid, addElemTb );
4273 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4274 createTool( SMESHOp::OpPolyhedron, addElemTb );
4276 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4277 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4278 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4279 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4280 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4281 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4282 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4283 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4284 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4285 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4287 createTool( SMESHOp::OpRemoveNodes, remTb );
4288 createTool( SMESHOp::OpRemoveElements, remTb );
4289 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4290 createTool( SMESHOp::OpClearMesh, remTb );
4292 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4293 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4295 createTool( SMESHOp::OpTranslation, transformTb );
4296 createTool( SMESHOp::OpRotation, transformTb );
4297 createTool( SMESHOp::OpSymmetry, transformTb );
4298 createTool( SMESHOp::OpScale, transformTb );
4299 createTool( SMESHOp::OpSewing, transformTb );
4300 createTool( SMESHOp::OpMergeNodes, transformTb );
4301 createTool( SMESHOp::OpMergeElements, transformTb );
4302 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4304 createTool( SMESHOp::OpMoveNode, modifyTb );
4305 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4306 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4307 createTool( SMESHOp::OpOrientation, modifyTb );
4308 createTool( SMESHOp::OpReorientFaces, modifyTb );
4309 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4310 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4311 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4312 createTool( SMESHOp::OpSmoothing, modifyTb );
4313 createTool( SMESHOp::OpExtrusion, modifyTb );
4314 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4315 createTool( SMESHOp::OpRevolution, modifyTb );
4316 createTool( SMESHOp::OpPatternMapping, modifyTb );
4317 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4318 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4320 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4322 createTool( SMESHOp::OpUpdate, dispModeTb );
4324 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4325 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4328 QString OB = "'ObjectBrowser'",
4329 View = "'" + SVTK_Viewer::Type() + "'",
4331 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4332 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4333 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4334 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4335 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4336 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4337 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4338 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4339 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4340 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4341 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4343 mesh_part = mesh + " " + subMesh + " " + group,
4344 mesh_group = mesh + " " + group,
4345 hyp_alg = hypo + " " + algo;
4347 // popup for object browser
4349 isInvisible("not( isVisible )"),
4350 isEmpty("numberOfNodes = 0"),
4351 isNotEmpty("numberOfNodes <> 0"),
4353 // has nodes, edges, etc in VISIBLE! actor
4354 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4355 hasElems("(count( elemTypes ) > 0)"),
4356 hasDifferentElems("(count( elemTypes ) > 1)"),
4357 hasBalls("({'BallElem'} in elemTypes)"),
4358 hasElems0d("({'Elem0d'} in elemTypes)"),
4359 hasEdges("({'Edge'} in elemTypes)"),
4360 hasFaces("({'Face'} in elemTypes)"),
4361 hasVolumes("({'Volume'} in elemTypes)");
4363 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4364 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4365 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4366 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4367 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4368 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4370 popupMgr()->insert( separator(), -1, 0 );
4371 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4372 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4373 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4374 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4375 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4376 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4377 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4378 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4379 popupMgr()->insert( separator(), -1, 0 );
4380 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4381 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4382 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4383 popupMgr()->insert( separator(), -1, 0 );
4384 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4385 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4386 popupMgr()->insert( separator(), -1, 0 );
4387 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4388 popupMgr()->insert( separator(), -1, 0 );
4389 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4390 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4392 popupMgr()->insert( separator(), -1, 0 );
4394 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4395 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4396 QString only_one_2D = only_one_non_empty + " && dim>1";
4398 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4399 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4400 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4401 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4403 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4405 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4406 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4407 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4408 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4409 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4410 popupMgr()->insert( separator(), -1, 0 );
4413 createPopupItem( SMESHOp::OpEditGroup, View, group );
4414 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4415 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4417 popupMgr()->insert( separator(), -1, 0 );
4418 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4419 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4420 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4421 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4422 popupMgr()->insert( separator(), -1, 0 );
4424 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4425 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4426 popupMgr()->insert( separator(), -1, 0 );
4428 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4429 QString aType = QString( "%1type in {%2}" ).arg( lc );
4430 aType = aType.arg( mesh_part );
4431 QString aMeshInVTK = aClient + "&&" + aType;
4433 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4434 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4435 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4437 //-------------------------------------------------
4439 //-------------------------------------------------
4440 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4442 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4443 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4444 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4446 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4447 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4448 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4450 popupMgr()->insert( separator(), -1, -1 );
4452 //-------------------------------------------------
4454 //-------------------------------------------------
4455 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4457 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4458 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4459 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4461 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4462 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4463 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4465 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4466 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4467 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4469 popupMgr()->insert( separator(), anId, -1 );
4471 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4472 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4473 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4475 //-------------------------------------------------
4477 //-------------------------------------------------
4478 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4480 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4482 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4483 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4484 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4486 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4487 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4488 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4490 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4491 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4492 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4494 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4495 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4496 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4498 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4499 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4500 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4502 popupMgr()->insert( separator(), anId, -1 );
4504 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4505 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4507 popupMgr()->insert( separator(), anId, -1 );
4509 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4510 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4513 //-------------------------------------------------
4514 // Representation of the 2D Quadratic elements
4515 //-------------------------------------------------
4516 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4517 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4518 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4519 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4521 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4522 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4523 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4525 //-------------------------------------------------
4526 // Orientation of faces
4527 //-------------------------------------------------
4528 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4529 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4530 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4532 //-------------------------------------------------
4534 //-------------------------------------------------
4535 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4536 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4538 //-------------------------------------------------
4540 //-------------------------------------------------
4541 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4544 //-------------------------------------------------
4546 //-------------------------------------------------
4548 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4549 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4550 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4551 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4553 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4555 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4556 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4558 popupMgr()->insert( separator(), anId, -1 );
4560 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4562 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4566 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4567 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4570 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4572 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4573 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4574 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4576 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4577 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4578 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4580 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4582 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4587 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4588 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4589 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4591 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4593 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4594 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4595 QtxPopupMgr::VisibleRule );
4596 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4598 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4600 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4602 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4603 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4606 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4614 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4615 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4616 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4618 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4619 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4620 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4622 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4624 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4626 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4628 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4630 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4631 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4632 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4634 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4635 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4636 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4638 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4639 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4640 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4641 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4642 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4643 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4645 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4647 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4649 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4652 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4653 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4655 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4657 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4659 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4660 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4661 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4663 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4667 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4671 popupMgr()->insert( separator(), anId, -1 );
4673 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4675 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4676 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4679 popupMgr()->insert( separator(), anId, -1 );
4681 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4683 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4684 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4686 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4688 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4690 #ifndef DISABLE_PLOT2DVIEWER
4691 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4692 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4695 //-------------------------------------------------
4697 //-------------------------------------------------
4698 popupMgr()->insert( separator(), -1, -1 );
4699 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4700 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4701 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4704 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4705 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4707 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4710 popupMgr()->insert( separator(), -1, -1 );
4712 //-------------------------------------------------
4714 //-------------------------------------------------
4715 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4716 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4718 popupMgr()->insert( separator(), -1, -1 );
4720 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4722 popupMgr()->insert( separator(), -1, -1 );
4724 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4725 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4727 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4728 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4731 //================================================================================
4733 * \brief Return true if SMESH or GEOM objects are selected.
4734 * Is called form LightApp_Module::activateModule() which clear selection if
4735 * not isSelectionCompatible()
4737 //================================================================================
4739 bool SMESHGUI::isSelectionCompatible()
4741 bool isCompatible = true;
4742 SALOME_ListIO selected;
4743 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4744 Sel->selectedObjects( selected );
4746 SALOME_ListIteratorOfListIO It( selected );
4747 for ( ; isCompatible && It.More(); It.Next())
4749 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4750 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4752 return isCompatible;
4756 bool SMESHGUI::reusableOperation( const int id )
4758 // compute, evaluate and precompute are not reusable operations
4759 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4762 bool SMESHGUI::activateModule( SUIT_Study* study )
4764 bool res = SalomeApp_Module::activateModule( study );
4766 setMenuShown( true );
4767 setToolShown( true );
4769 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4770 PyGILState_STATE gstate = PyGILState_Ensure();
4771 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4772 if ( !pluginsmanager ) {
4776 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4780 PyGILState_Release(gstate);
4781 // end of SMESH plugins loading
4783 // Reset actions accelerator keys
4784 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4786 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4787 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4788 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4789 if ( _PTR(Study) aStudy = s->studyDS()) {
4790 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4791 updateObjBrowser(); // objects can be removed
4794 // get all view currently opened in the study and connect their signals to
4795 // the corresponding slots of the class.
4796 SUIT_Desktop* aDesk = study->application()->desktop();
4798 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4799 SUIT_ViewWindow* wnd;
4800 foreach ( wnd, wndList )
4807 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4809 setMenuShown( false );
4810 setToolShown( false );
4812 EmitSignalCloseAllDialogs();
4814 // Unset actions accelerator keys
4815 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4817 return SalomeApp_Module::deactivateModule( study );
4820 void SMESHGUI::studyClosed( SUIT_Study* s )
4824 SMESH::RemoveVisuData( s->id() );
4825 SalomeApp_Module::studyClosed( s );
4828 void SMESHGUI::OnGUIEvent()
4830 const QObject* obj = sender();
4831 if ( !obj || !obj->inherits( "QAction" ) )
4833 int id = actionId((QAction*)obj);
4838 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4840 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4841 if ( CORBA::is_nil( myComponentSMESH ) )
4843 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4845 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4846 return aGUI.myComponentSMESH;
4849 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4850 return myComponentSMESH;
4853 QString SMESHGUI::engineIOR() const
4855 CORBA::ORB_var anORB = getApp()->orb();
4856 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4857 return QString( anIOR.in() );
4860 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4862 SalomeApp_Module::contextMenuPopup( client, menu, title );
4864 selectionMgr()->selectedObjects( lst );
4865 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4866 Handle(SALOME_InteractiveObject) io = lst.First();
4867 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4868 _PTR(Study) study = appStudy->studyDS();
4869 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4871 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4872 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4873 aName.remove( (aName.length() - 1), 1 );
4879 LightApp_Selection* SMESHGUI::createSelection() const
4881 return new SMESHGUI_Selection();
4884 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4886 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4887 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4888 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4891 void SMESHGUI::viewManagers( QStringList& list ) const
4893 list.append( SVTK_Viewer::Type() );
4896 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4898 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4899 SMESH::UpdateSelectionProp( this );
4901 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4902 for(int i = 0; i < aViews.count() ; i++){
4903 SUIT_ViewWindow *sf = aViews[i];
4906 EmitSignalActivatedViewManager();
4910 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4912 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4913 myClippingPlaneInfoMap.erase( theViewManager );
4916 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4918 theActor->AddObserver( SMESH::DeleteActorEvent,
4919 myEventCallbackCommand.GetPointer(),
4923 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4924 unsigned long theEvent,
4925 void* theClientData,
4928 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4929 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4930 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4931 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4932 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4933 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4934 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4935 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4936 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4937 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4938 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4939 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4940 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4941 if( anActor == *anIter3 ) {
4942 anActorList.erase( anIter3 );
4953 void SMESHGUI::createPreferences()
4955 // General tab ------------------------------------------------------------------------
4956 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4958 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4959 setPreferenceProperty( autoUpdate, "columns", 2 );
4960 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4961 setPreferenceProperty( lim, "min", 0 );
4962 setPreferenceProperty( lim, "max", 100000000 );
4963 setPreferenceProperty( lim, "step", 1000 );
4964 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4965 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4967 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4968 setPreferenceProperty( qaGroup, "columns", 2 );
4969 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4970 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4971 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4972 setPreferenceProperty( prec, "min", 0 );
4973 setPreferenceProperty( prec, "max", 100 );
4974 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4975 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4976 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4977 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4978 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4980 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4981 setPreferenceProperty( dispgroup, "columns", 2 );
4982 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4984 modes.append( tr("MEN_WIRE") );
4985 modes.append( tr("MEN_SHADE") );
4986 modes.append( tr("MEN_NODES") );
4987 modes.append( tr("MEN_SHRINK") );
4988 QList<QVariant> indices;
4989 indices.append( 0 );
4990 indices.append( 1 );
4991 indices.append( 2 );
4992 indices.append( 3 );
4993 setPreferenceProperty( dispmode, "strings", modes );
4994 setPreferenceProperty( dispmode, "indexes", indices );
4996 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4997 setPreferenceProperty( arcgroup, "columns", 2 );
4998 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4999 QStringList quadraticModes;
5000 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5001 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5003 indices.append( 0 );
5004 indices.append( 1 );
5005 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5006 setPreferenceProperty( quadraticmode, "indexes", indices );
5008 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5009 "SMESH", "max_angle" );
5010 setPreferenceProperty( maxAngle, "min", 1 );
5011 setPreferenceProperty( maxAngle, "max", 90 );
5015 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5016 setPreferenceProperty( exportgroup, "columns", 2 );
5017 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5018 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5020 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5021 setPreferenceProperty( computeGroup, "columns", 2 );
5022 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5024 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5025 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5026 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5028 indices.append( 0 );
5029 indices.append( 1 );
5030 indices.append( 2 );
5031 setPreferenceProperty( notifyMode, "strings", modes );
5032 setPreferenceProperty( notifyMode, "indexes", indices );
5034 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5035 setPreferenceProperty( infoGroup, "columns", 2 );
5036 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5038 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5039 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5041 indices.append( 0 );
5042 indices.append( 1 );
5043 setPreferenceProperty( elemInfo, "strings", modes );
5044 setPreferenceProperty( elemInfo, "indexes", indices );
5045 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5046 setPreferenceProperty( nodesLim, "min", 0 );
5047 setPreferenceProperty( nodesLim, "max", 10000000 );
5048 setPreferenceProperty( nodesLim, "step", 10000 );
5049 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5050 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5051 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5052 setPreferenceProperty( ctrlLim, "min", 0 );
5053 setPreferenceProperty( ctrlLim, "max", 10000000 );
5054 setPreferenceProperty( ctrlLim, "step", 1000 );
5055 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5056 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5057 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5058 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5059 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5061 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5062 setPreferenceProperty( segGroup, "columns", 2 );
5063 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5064 "SMESH", "segmentation" );
5065 setPreferenceProperty( segLen, "min", 1 );
5066 setPreferenceProperty( segLen, "max", 10000000 );
5067 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5068 "SMESH", "nb_segments_per_edge" );
5069 setPreferenceProperty( nbSeg, "min", 1 );
5070 setPreferenceProperty( nbSeg, "max", 10000000 );
5072 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5073 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5074 "SMESH", "forget_mesh_on_hyp_modif" );
5077 // Quantities with individual precision settings
5078 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5079 setPreferenceProperty( precGroup, "columns", 2 );
5081 const int nbQuantities = 6;
5082 int precs[nbQuantities], ii = 0;
5083 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5084 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5085 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5086 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5087 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5088 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5089 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5090 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5091 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5092 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5093 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5094 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5096 // Set property for precision value for spinboxes
5097 for ( ii = 0; ii < nbQuantities; ii++ ){
5098 setPreferenceProperty( precs[ii], "min", -14 );
5099 setPreferenceProperty( precs[ii], "max", 14 );
5100 setPreferenceProperty( precs[ii], "precision", 2 );
5103 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5104 setPreferenceProperty( previewGroup, "columns", 2 );
5105 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5106 setPreferenceProperty( chunkSize, "min", 1 );
5107 setPreferenceProperty( chunkSize, "max", 1000 );
5108 setPreferenceProperty( chunkSize, "step", 50 );
5110 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5111 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5113 // Mesh tab ------------------------------------------------------------------------
5114 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5115 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5116 setPreferenceProperty( nodeGroup, "columns", 3 );
5118 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5120 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5122 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5123 QList<QVariant> aMarkerTypeIndicesList;
5124 QList<QVariant> aMarkerTypeIconsList;
5125 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5126 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5127 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5128 aMarkerTypeIndicesList << i;
5129 aMarkerTypeIconsList << pixmap;
5131 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5132 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5134 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5136 QList<QVariant> aMarkerScaleIndicesList;
5137 QStringList aMarkerScaleValuesList;
5138 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5139 aMarkerScaleIndicesList << i;
5140 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5142 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5143 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5145 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5146 //setPreferenceProperty( elemGroup, "columns", 2 );
5148 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5149 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5150 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5151 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5152 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5153 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5154 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5155 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5156 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5159 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5160 setPreferenceProperty( grpGroup, "columns", 2 );
5162 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5163 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5165 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5166 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5167 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5168 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5169 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5170 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5171 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5172 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5173 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5174 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5175 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5176 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5177 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5178 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5180 setPreferenceProperty( size0d, "min", 1 );
5181 setPreferenceProperty( size0d, "max", 10 );
5183 // setPreferenceProperty( ballSize, "min", 1 );
5184 // setPreferenceProperty( ballSize, "max", 10 );
5186 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5187 setPreferenceProperty( ballDiameter, "max", 1e9 );
5188 setPreferenceProperty( ballDiameter, "step", 0.1 );
5190 setPreferenceProperty( ballScale, "min", 1e-2 );
5191 setPreferenceProperty( ballScale, "max", 1e7 );
5192 setPreferenceProperty( ballScale, "step", 0.5 );
5194 setPreferenceProperty( elemW, "min", 1 );
5195 setPreferenceProperty( elemW, "max", 5 );
5197 setPreferenceProperty( outW, "min", 1 );
5198 setPreferenceProperty( outW, "max", 5 );
5200 setPreferenceProperty( shrink, "min", 0 );
5201 setPreferenceProperty( shrink, "max", 100 );
5203 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5204 setPreferenceProperty( numGroup, "columns", 2 );
5206 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5207 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5209 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5210 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5212 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5213 setPreferenceProperty( orientGroup, "columns", 1 );
5215 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5216 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5218 setPreferenceProperty( orientScale, "min", 0.05 );
5219 setPreferenceProperty( orientScale, "max", 0.5 );
5220 setPreferenceProperty( orientScale, "step", 0.05 );
5222 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5224 // Selection tab ------------------------------------------------------------------------
5225 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5227 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5228 setPreferenceProperty( selGroup, "columns", 2 );
5230 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5231 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5233 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5234 setPreferenceProperty( preGroup, "columns", 2 );
5236 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5238 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5239 setPreferenceProperty( precSelGroup, "columns", 2 );
5241 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5242 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5243 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5245 // Scalar Bar tab ------------------------------------------------------------------------
5246 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5247 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5248 setPreferenceProperty( fontGr, "columns", 2 );
5250 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5251 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5253 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5254 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5256 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5257 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5259 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5260 setPreferenceProperty( numcol, "min", 2 );
5261 setPreferenceProperty( numcol, "max", 256 );
5263 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5264 setPreferenceProperty( numlab, "min", 2 );
5265 setPreferenceProperty( numlab, "max", 65 );
5267 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5268 setPreferenceProperty( orientGr, "columns", 2 );
5269 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5270 QStringList orients;
5271 orients.append( tr( "SMESH_VERTICAL" ) );
5272 orients.append( tr( "SMESH_HORIZONTAL" ) );
5273 indices.clear(); indices.append( 0 ); indices.append( 1 );
5274 setPreferenceProperty( orient, "strings", orients );
5275 setPreferenceProperty( orient, "indexes", indices );
5277 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5278 setPreferenceProperty( posVSizeGr, "columns", 2 );
5279 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5280 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5281 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5282 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5283 setPreferenceProperty( xv, "step", 0.1 );
5284 setPreferenceProperty( xv, "min", 0.0 );
5285 setPreferenceProperty( xv, "max", 1.0 );
5286 setPreferenceProperty( yv, "step", 0.1 );
5287 setPreferenceProperty( yv, "min", 0.0 );
5288 setPreferenceProperty( yv, "max", 1.0 );
5289 setPreferenceProperty( wv, "step", 0.1 );
5290 setPreferenceProperty( wv, "min", 0.0 );
5291 setPreferenceProperty( wv, "max", 1.0 );
5292 setPreferenceProperty( hv, "min", 0.0 );
5293 setPreferenceProperty( hv, "max", 1.0 );
5294 setPreferenceProperty( hv, "step", 0.1 );
5296 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5297 setPreferenceProperty( posHSizeGr, "columns", 2 );
5298 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5299 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5300 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5301 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5302 setPreferenceProperty( xv, "min", 0.0 );
5303 setPreferenceProperty( xv, "max", 1.0 );
5304 setPreferenceProperty( xv, "step", 0.1 );
5305 setPreferenceProperty( xh, "min", 0.0 );
5306 setPreferenceProperty( xh, "max", 1.0 );
5307 setPreferenceProperty( xh, "step", 0.1 );
5308 setPreferenceProperty( yh, "min", 0.0 );
5309 setPreferenceProperty( yh, "max", 1.0 );
5310 setPreferenceProperty( yh, "step", 0.1 );
5311 setPreferenceProperty( wh, "min", 0.0 );
5312 setPreferenceProperty( wh, "max", 1.0 );
5313 setPreferenceProperty( wh, "step", 0.1 );
5314 setPreferenceProperty( hh, "min", 0.0 );
5315 setPreferenceProperty( hh, "max", 1.0 );
5316 setPreferenceProperty( hh, "step", 0.1 );
5318 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5319 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5320 setPreferenceProperty( distributionGr, "columns", 3 );
5322 types.append( tr( "SMESH_MONOCOLOR" ) );
5323 types.append( tr( "SMESH_MULTICOLOR" ) );
5324 indices.clear(); indices.append( 0 ); indices.append( 1 );
5325 setPreferenceProperty( coloringType, "strings", types );
5326 setPreferenceProperty( coloringType, "indexes", indices );
5327 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5331 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5333 if( sect=="SMESH" ) {
5334 float sbX1,sbY1,sbW,sbH;
5335 float aTol = 1.00000009999999;
5336 std::string aWarning;
5337 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5338 if( name=="selection_object_color" || name=="selection_element_color" ||
5339 name=="highlight_color" ||
5340 name=="selection_precision_node" || name=="selection_precision_element" ||
5341 name=="selection_precision_object")
5342 SMESH::UpdateSelectionProp( this );
5343 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5344 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5345 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5346 if(sbX1+sbW > aTol){
5347 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5350 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5351 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5354 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5355 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5356 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5357 if(sbY1+sbH > aTol){
5358 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5359 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5360 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5363 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5364 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5365 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5366 if(sbX1+sbW > aTol){
5367 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5370 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5371 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5374 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5375 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5376 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5377 if(sbY1+sbH > aTol){
5378 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5381 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5382 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5385 else if ( name == "segmentation" ) {
5386 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5387 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5389 else if ( name == "nb_segments_per_edge" ) {
5390 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5391 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5393 else if ( name == "historical_python_dump" ||
5394 name == "forget_mesh_on_hyp_modif") {
5395 QString val = aResourceMgr->stringValue( "SMESH", name );
5396 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5398 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5399 SMESH::UpdateFontProp( this );
5401 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5402 SMESH::UpdateFontProp( this );
5405 if(aWarning.size() != 0){
5406 aWarning += "The default values are applied instead.";
5407 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5408 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5409 QObject::tr(aWarning.c_str()));
5414 //================================================================================
5416 * \brief Update something in accordance with update flags
5417 * \param theFlags - update flags
5419 * Update viewer or/and object browser etc. in accordance with update flags ( see
5420 * LightApp_UpdateFlags enumeration ).
5422 //================================================================================
5423 void SMESHGUI::update( const int flags )
5425 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5426 SMESH::UpdateView();
5428 SalomeApp_Module::update( flags );
5431 //================================================================================
5433 * \brief Set default selection mode
5435 * SLOT called when operation commited. Sets default selection mode
5437 //================================================================================
5438 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5440 SVTK_ViewWindow* vtkWnd =
5441 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5443 vtkWnd->SetSelectionMode( ActorSelection );
5446 //================================================================================
5448 * \brief Set default selection mode
5450 * SLOT called when operation aborted. Sets default selection mode
5452 //================================================================================
5453 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5455 SVTK_ViewWindow* vtkWnd =
5456 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5458 vtkWnd->SetSelectionMode( ActorSelection );
5461 //================================================================================
5463 * \brief Creates operation with given identifier
5464 * \param id - identifier of operation to be started
5465 * \return Pointer on created operation or NULL if operation is not created
5467 * Virtual method redefined from the base class creates operation with given id.
5468 * It is called called automatically from startOperation method of base class.
5470 //================================================================================
5471 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5473 LightApp_Operation* op = 0;
5474 // to do : create operation here
5477 case SMESHOp::OpConvertMeshToQuadratic:
5478 op = new SMESHGUI_ConvToQuadOp();
5480 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5481 op = new SMESHGUI_Make2DFrom3DOp();
5483 case SMESHOp::OpReorientFaces:
5484 op = new SMESHGUI_ReorientFacesOp();
5486 case SMESHOp::OpCreateMesh:
5487 op = new SMESHGUI_MeshOp( true, true );
5489 case SMESHOp::OpCreateSubMesh:
5490 op = new SMESHGUI_MeshOp( true, false );
5492 case SMESHOp::OpEditMeshOrSubMesh:
5493 op = new SMESHGUI_MeshOp( false );
5495 case SMESHOp::OpCompute:
5496 op = new SMESHGUI_ComputeOp();
5498 case SMESHOp::OpPreCompute:
5499 op = new SMESHGUI_PrecomputeOp();
5501 case SMESHOp::OpEvaluate:
5502 op = new SMESHGUI_EvaluateOp();
5504 case SMESHOp::OpMeshOrder:
5505 op = new SMESHGUI_MeshOrderOp();
5507 case SMESHOp::OpCreateGeometryGroup:
5508 op = new SMESHGUI_GroupOnShapeOp();
5510 case SMESHOp::OpFindElementByPoint:
5511 op = new SMESHGUI_FindElemByPointOp();
5513 case SMESHOp::OpMoveNode: // Make mesh pass through point
5514 op = new SMESHGUI_MakeNodeAtPointOp();
5516 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5517 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5524 op = SalomeApp_Module::createOperation( id );
5528 //================================================================================
5530 * \brief Stops current operations and starts a given one
5531 * \param id - The id of the operation to start
5533 //================================================================================
5535 void SMESHGUI::switchToOperation(int id)
5537 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5538 activeStudy()->abortAllOperations();
5539 startOperation( id );
5542 LightApp_Displayer* SMESHGUI::displayer()
5545 myDisplayer = new SMESHGUI_Displayer( getApp() );
5549 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5552 int aTolerance = 64;
5553 int anIterations = 0;
5559 if( anIterations % aPeriod == 0 )
5562 if( aTolerance < 1 )
5566 aHue = (int)( 360.0 * rand() / RAND_MAX );
5569 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5570 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5571 for( ; it != itEnd; ++it )
5573 SALOMEDS::Color anAutoColor = *it;
5574 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5577 aQColor.getHsv( &h, &s, &v );
5578 if( abs( h - aHue ) < aTolerance )
5590 aColor.setHsv( aHue, 255, 255 );
5592 SALOMEDS::Color aSColor;
5593 aSColor.R = aColor.redF();
5594 aSColor.G = aColor.greenF();
5595 aSColor.B = aColor.blueF();
5600 const char* gSeparator = "_"; // character used to separate parameter names
5601 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5602 const char* gPathSep = "|"; // character used to separate paths
5605 * \brief Store visual parameters
5607 * This method is called just before the study document is saved.
5608 * Store visual parameters in AttributeParameter attribue(s)
5610 void SMESHGUI::storeVisualParameters (int savePoint)
5613 Kernel_Utils::Localizer loc;
5615 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5616 if (!appStudy || !appStudy->studyDS())
5618 _PTR(Study) studyDS = appStudy->studyDS();
5620 // componentName is used for encoding of entries when storing them in IParameters
5621 std::string componentName = myComponentSMESH->ComponentDataType();
5622 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5623 //if (!aSComponent) return;
5626 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5627 componentName.c_str(),
5629 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5631 // store map of custom markers
5632 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5633 if( !aMarkerMap.empty() )
5635 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5636 for( ; anIter != aMarkerMap.end(); anIter++ )
5638 int anId = anIter->first;
5639 VTK::MarkerData aMarkerData = anIter->second;
5640 std::string aMarkerFileName = aMarkerData.first;
5641 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5642 if( aMarkerTexture.size() < 3 )
5643 continue; // should contain at least width, height and the first value
5645 QString aPropertyName( "texture" );
5646 aPropertyName += gSeparator;
5647 aPropertyName += QString::number( anId );
5649 QString aPropertyValue = aMarkerFileName.c_str();
5650 aPropertyValue += gPathSep;
5652 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5653 ushort aWidth = *aTextureIter++;
5654 ushort aHeight = *aTextureIter++;
5655 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5656 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5657 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5658 aPropertyValue += QString::number( *aTextureIter );
5660 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5664 // viewers counters are used for storing view_numbers in IParameters
5667 // main cycle to store parameters of displayed objects
5668 QList<SUIT_ViewManager*> lst;
5669 QList<SUIT_ViewManager*>::Iterator it;
5670 getApp()->viewManagers(lst);
5671 for (it = lst.begin(); it != lst.end(); it++)
5673 SUIT_ViewManager* vman = *it;
5674 QString vType = vman->getType();
5676 // saving VTK actors properties
5677 if (vType == SVTK_Viewer::Type())
5679 // store the clipping planes attached to the view manager
5680 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5681 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5682 if( anIter != myClippingPlaneInfoMap.end() )
5683 aClippingPlaneInfoList = anIter->second;
5685 if( !aClippingPlaneInfoList.empty() ) {
5686 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5687 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5689 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5690 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5692 QString aPropertyName( "ClippingPlane" );
5693 aPropertyName += gSeparator;
5694 aPropertyName += QString::number( vtkViewers );
5695 aPropertyName += gSeparator;
5696 aPropertyName += QString::number( anId );
5698 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5699 aPropertyValue += gDigitsSep;
5700 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5701 aPropertyValue += gDigitsSep;
5702 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5703 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5704 aPropertyValue += gDigitsSep;
5705 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5706 aPropertyValue += gDigitsSep;
5707 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5708 aPropertyValue += gDigitsSep;
5709 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5710 aPropertyValue += gDigitsSep;
5711 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5712 aPropertyValue += gDigitsSep;
5713 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5714 aPropertyValue += gDigitsSep;
5715 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5717 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5718 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5719 aPropertyValue += gDigitsSep;
5720 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5721 aPropertyValue += gDigitsSep;
5722 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5723 aPropertyValue += gDigitsSep;
5724 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5727 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5731 QVector<SUIT_ViewWindow*> views = vman->getViews();
5732 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5734 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5736 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5737 vtkActorCollection* allActors = aCopy.GetActors();
5738 allActors->InitTraversal();
5739 while (vtkActor* actor = allActors->GetNextActor())
5741 if (actor->GetVisibility()) // store only visible actors
5743 SMESH_Actor* aSmeshActor = 0;
5744 if (actor->IsA("SMESH_Actor"))
5745 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5746 if (aSmeshActor && aSmeshActor->hasIO())
5748 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5751 // entry is "encoded" = it does NOT contain component adress,
5752 // since it is a subject to change on next component loading
5753 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5755 std::string param, vtkParam = vType.toLatin1().data();
5756 vtkParam += gSeparator;
5757 vtkParam += QString::number(vtkViewers).toLatin1().data();
5758 vtkParam += gSeparator;
5761 param = vtkParam + "Visibility";
5762 ip->setParameter(entry, param, "On");
5765 param = vtkParam + "Representation";
5766 ip->setParameter(entry, param, QString::number
5767 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5770 param = vtkParam + "IsShrunk";
5771 ip->setParameter(entry, param, QString::number
5772 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5774 // Displayed entities
5775 unsigned int aMode = aSmeshActor->GetEntityMode();
5776 bool isE = aMode & SMESH_Actor::eEdges;
5777 bool isF = aMode & SMESH_Actor::eFaces;
5778 bool isV = aMode & SMESH_Actor::eVolumes;
5779 bool is0d = aMode & SMESH_Actor::e0DElements;
5780 bool isB = aMode & SMESH_Actor::eBallElem;
5782 QString modeStr ("e");
5783 modeStr += gDigitsSep; modeStr += QString::number(isE);
5784 modeStr += gDigitsSep; modeStr += "f";
5785 modeStr += gDigitsSep; modeStr += QString::number(isF);
5786 modeStr += gDigitsSep; modeStr += "v";
5787 modeStr += gDigitsSep; modeStr += QString::number(isV);
5788 modeStr += gDigitsSep; modeStr += "0d";
5789 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5790 modeStr += gDigitsSep; modeStr += "b";
5791 modeStr += gDigitsSep; modeStr += QString::number(isB);
5793 param = vtkParam + "Entities";
5794 ip->setParameter(entry, param, modeStr.toLatin1().data());
5800 aSmeshActor->GetSufaceColor(r, g, b, delta);
5801 QStringList colorStr;
5802 colorStr << "surface";
5803 colorStr << QString::number(r);
5804 colorStr << QString::number(g);
5805 colorStr << QString::number(b);
5807 colorStr << "backsurface";
5808 colorStr << QString::number(delta);
5810 aSmeshActor->GetVolumeColor(r, g, b, delta);
5811 colorStr << "volume";
5812 colorStr << QString::number(r);
5813 colorStr << QString::number(g);
5814 colorStr << QString::number(b);
5815 colorStr << QString::number(delta);
5817 aSmeshActor->GetEdgeColor(r, g, b);
5819 colorStr << QString::number(r);
5820 colorStr << QString::number(g);
5821 colorStr << QString::number(b);
5823 aSmeshActor->GetNodeColor(r, g, b);
5825 colorStr << QString::number(r);
5826 colorStr << QString::number(g);
5827 colorStr << QString::number(b);
5829 aSmeshActor->GetOutlineColor(r, g, b);
5830 colorStr << "outline";
5831 colorStr << QString::number(r);
5832 colorStr << QString::number(g);
5833 colorStr << QString::number(b);
5835 aSmeshActor->Get0DColor(r, g, b);
5836 colorStr << "elem0d";
5837 colorStr << QString::number(r);
5838 colorStr << QString::number(g);
5839 colorStr << QString::number(b);
5841 aSmeshActor->GetBallColor(r, g, b);
5843 colorStr << QString::number(r);
5844 colorStr << QString::number(g);
5845 colorStr << QString::number(b);
5847 aSmeshActor->GetFacesOrientationColor(r, g, b);
5848 colorStr << "orientation";
5849 colorStr << QString::number(r);
5850 colorStr << QString::number(g);
5851 colorStr << QString::number(b);
5853 param = vtkParam + "Colors";
5854 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5857 QStringList sizeStr;
5859 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5860 sizeStr << "outline";
5861 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5862 sizeStr << "elem0d";
5863 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5865 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5866 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5867 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5868 sizeStr << "shrink";
5869 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5870 sizeStr << "orientation";
5871 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5872 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5874 param = vtkParam + "Sizes";
5875 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5880 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5881 if( aMarkerType == VTK::MT_USER ) {
5882 markerStr += "custom";
5883 markerStr += gDigitsSep;
5884 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5888 markerStr += gDigitsSep;
5889 markerStr += QString::number( (int)aMarkerType );
5890 markerStr += gDigitsSep;
5891 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5894 param = vtkParam + "PointMarker";
5895 ip->setParameter(entry, param, markerStr.toLatin1().data());
5898 param = vtkParam + "Opacity";
5899 ip->setParameter(entry, param,
5900 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5903 param = vtkParam + "ClippingPlane";
5905 if( !aClippingPlaneInfoList.empty() ) {
5906 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5907 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5909 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5910 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5911 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5912 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5913 if( aSmeshActor == *anIter2 ) {
5914 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5915 QString::number( anId ).toLatin1().constData() );
5922 ip->setParameter( entry, param, "Off" );
5923 } // if (io->hasEntry())
5924 } // SMESH_Actor && hasIO
5926 } // while.. actors traversal
5930 } // if (SVTK view model)
5931 } // for (viewManagers)
5934 // data structures for clipping planes processing
5938 bool isOpenGLClipping;
5939 vtkIdType RelativeOrientation;
5942 int AbsoluteOrientation;
5943 double X, Y, Z, Dx, Dy, Dz;
5945 typedef std::list<TPlaneData> TPlaneDataList;
5946 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5948 typedef std::list<vtkActor*> TActorList;
5951 TActorList ActorList;
5952 SUIT_ViewManager* ViewManager;
5954 typedef std::list<TPlaneInfo> TPlaneInfoList;
5955 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5958 * \brief Restore visual parameters
5960 * This method is called after the study document is opened.
5961 * Restore visual parameters from AttributeParameter attribue(s)
5963 void SMESHGUI::restoreVisualParameters (int savePoint)
5966 Kernel_Utils::Localizer loc;
5968 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5969 if (!appStudy || !appStudy->studyDS())
5971 _PTR(Study) studyDS = appStudy->studyDS();
5973 // componentName is used for encoding of entries when storing them in IParameters
5974 std::string componentName = myComponentSMESH->ComponentDataType();
5975 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5976 //if (!aSComponent) return;
5979 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5980 componentName.c_str(),
5982 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5984 // restore map of custom markers and map of clipping planes
5985 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5986 TPlaneDataMap aPlaneDataMap;
5988 std::vector<std::string> properties = ip->getProperties();
5989 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5991 std::string property = *propIt;
5992 QString aPropertyName( property.c_str() );
5993 QString aPropertyValue( ip->getProperty( property ).c_str() );
5995 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5996 if( aPropertyNameList.isEmpty() )
5999 QString aPropertyType = aPropertyNameList[0];
6000 if( aPropertyType == "texture" )
6002 if( aPropertyNameList.size() != 2 )
6006 int anId = aPropertyNameList[1].toInt( &ok );
6007 if( !ok || anId < 1 )
6010 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6011 if( aPropertyValueList.size() != 2 )
6014 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6015 QString aMarkerTextureString = aPropertyValueList[1];
6016 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6017 if( aMarkerTextureStringList.size() != 3 )
6021 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6026 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6030 VTK::MarkerTexture aMarkerTexture;
6031 aMarkerTexture.push_back( aWidth );
6032 aMarkerTexture.push_back( aHeight );
6034 QString aMarkerTextureData = aMarkerTextureStringList[2];
6035 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6037 QChar aChar = aMarkerTextureData.at( i );
6038 if( aChar.isDigit() )
6039 aMarkerTexture.push_back( aChar.digitValue() );
6042 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6044 else if( aPropertyType == "ClippingPlane" )
6046 if( aPropertyNameList.size() != 3 )
6050 int aViewId = aPropertyNameList[1].toInt( &ok );
6051 if( !ok || aViewId < 0 )
6055 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6056 if( !ok || aClippingPlaneId < 0 )
6059 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6060 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6063 TPlaneData aPlaneData;
6064 aPlaneData.Id = aClippingPlaneId;
6067 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6072 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6076 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6079 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6084 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6089 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6094 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6099 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6104 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6109 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6113 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6115 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6120 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6125 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6130 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6135 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6136 aPlaneDataList.push_back( aPlaneData );
6140 TPlaneInfoMap aPlaneInfoMap;
6142 std::vector<std::string> entries = ip->getEntries();
6144 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6146 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6147 QString entry (ip->decodeEntry(*entIt).c_str());
6149 // Check that the entry corresponds to a real object in the Study
6150 // as the object may be deleted or modified after the visual state is saved.
6151 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6152 if (!so) continue; //Skip the not existent entry
6154 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6155 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6157 std::vector<std::string>::iterator namesIt = paramNames.begin();
6158 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6160 // actors are stored in a map after displaying of them for
6161 // quicker access in the future: map < viewID to actor >
6162 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6164 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6166 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6167 // '_' is used as separator and should not be used in viewer type or parameter names.
6168 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6169 if (lst.size() != 3)
6172 QString viewerTypStr = lst[0];
6173 QString viewIndexStr = lst[1];
6174 QString paramNameStr = lst[2];
6177 int viewIndex = viewIndexStr.toUInt(&ok);
6178 if (!ok) // bad conversion of view index to integer
6182 if (viewerTypStr == SVTK_Viewer::Type())
6184 SMESH_Actor* aSmeshActor = 0;
6185 if (vtkActors.IsBound(viewIndex))
6186 aSmeshActor = vtkActors.Find(viewIndex);
6188 QList<SUIT_ViewManager*> lst;
6189 getApp()->viewManagers(viewerTypStr, lst);
6191 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6192 SUIT_ViewManager* vman = NULL;
6193 if (viewIndex >= 0 && viewIndex < lst.count())
6194 vman = lst.at(viewIndex);
6196 if (paramNameStr == "Visibility")
6198 if (!aSmeshActor && displayer() && vman)
6200 SUIT_ViewModel* vmodel = vman->getViewModel();
6201 // SVTK view model can be casted to SALOME_View
6202 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6204 // store displayed actor in a temporary map for quicker
6205 // access later when restoring other parameters
6206 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6207 vtkRenderer* Renderer = vtkView->getRenderer();
6208 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6209 vtkActorCollection* theActors = aCopy.GetActors();
6210 theActors->InitTraversal();
6211 bool isFound = false;
6212 vtkActor *ac = theActors->GetNextActor();
6213 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6214 if (ac->IsA("SMESH_Actor")) {
6215 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6216 if (aGeomAc->hasIO()) {
6217 Handle(SALOME_InteractiveObject) io =
6218 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6219 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6221 vtkActors.Bind(viewIndex, aGeomAc);
6227 } // if (paramNameStr == "Visibility")
6230 // the rest properties "work" with SMESH_Actor
6233 QString val ((*valuesIt).c_str());
6236 if (paramNameStr == "Representation") {
6237 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6240 else if (paramNameStr == "IsShrunk") {
6242 if (!aSmeshActor->IsShrunk())
6243 aSmeshActor->SetShrink();
6246 if (aSmeshActor->IsShrunk())
6247 aSmeshActor->UnShrink();
6250 // Displayed entities
6251 else if (paramNameStr == "Entities") {
6252 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6253 int aEntityMode = SMESH_Actor::eAllEntity;
6254 for ( int i = 0; i < mode.count(); i+=2 ) {
6255 if ( i < mode.count()-1 ) {
6256 QString type = mode[i];
6257 bool val = mode[i+1].toInt();
6258 if ( type == "e" && !val )
6259 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6260 else if ( type == "f" && !val )
6261 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6262 else if ( type == "v" && !val )
6263 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6264 else if ( type == "0d" && !val )
6265 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6266 else if ( type == "b" && !val )
6267 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6270 aSmeshActor->SetEntityMode( aEntityMode );
6273 else if (paramNameStr == "Colors") {
6274 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6281 QColor outlineColor;
6282 QColor orientationColor;
6288 // below lines are required to get default values for delta coefficients
6289 // of backface color for faces and color of reversed volumes
6290 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6291 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6292 for ( int i = 0; i < colors.count(); i++ ) {
6293 QString type = colors[i];
6294 if ( type == "surface" ) {
6295 // face color is set by 3 values r:g:b, where
6296 // - r,g,b - is rgb color components
6297 if ( i+1 >= colors.count() ) break; // format error
6298 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6299 if ( i+2 >= colors.count() ) break; // format error
6300 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6301 if ( i+3 >= colors.count() ) break; // format error
6302 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6303 faceColor.setRgbF( r, g, b );
6306 else if ( type == "backsurface" ) {
6307 // backface color can be defined in several ways
6308 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6309 // - in latest versions, it is set as delta coefficient
6310 bool rgbOk = false, deltaOk;
6311 if ( i+1 >= colors.count() ) break; // format error
6312 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6313 int delta = colors[i+1].toInt( &deltaOk );
6315 if ( i+1 < colors.count() ) // index is shifted to 1
6316 g = colors[i+1].toDouble( &rgbOk );
6317 if ( rgbOk ) i++; // shift index
6318 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6319 b = colors[i+1].toDouble( &rgbOk );
6321 // - as currently there's no way to set directly backsurface color as it was before,
6322 // we ignore old dump where r,g,b triple was set
6323 // - also we check that delta parameter is set properly
6324 if ( !rgbOk && deltaOk )
6327 else if ( type == "volume" ) {
6328 // volume color is set by 4 values r:g:b:delta, where
6329 // - r,g,b - is a normal volume rgb color components
6330 // - delta - is a reversed volume color delta coefficient
6331 if ( i+1 >= colors.count() ) break; // format error
6332 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6333 if ( i+2 >= colors.count() ) break; // format error
6334 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6335 if ( i+3 >= colors.count() ) break; // format error
6336 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6337 if ( i+4 >= colors.count() ) break; // format error
6338 int delta = colors[i+4].toInt( &bOk );
6339 if ( !bOk ) break; // format error
6340 volumeColor.setRgbF( r, g, b );
6344 else if ( type == "edge" ) {
6345 // edge color is set by 3 values r:g:b, where
6346 // - r,g,b - is rgb color components
6347 if ( i+1 >= colors.count() ) break; // format error
6348 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6349 if ( i+2 >= colors.count() ) break; // format error
6350 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6351 if ( i+3 >= colors.count() ) break; // format error
6352 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6353 edgeColor.setRgbF( r, g, b );
6356 else if ( type == "node" ) {
6357 // node color is set by 3 values r:g:b, where
6358 // - r,g,b - is rgb color components
6359 if ( i+1 >= colors.count() ) break; // format error
6360 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6361 if ( i+2 >= colors.count() ) break; // format error
6362 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6363 if ( i+3 >= colors.count() ) break; // format error
6364 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6365 nodeColor.setRgbF( r, g, b );
6368 else if ( type == "elem0d" ) {
6369 // 0d element color is set by 3 values r:g:b, where
6370 // - r,g,b - is rgb color components
6371 if ( i+1 >= colors.count() ) break; // format error
6372 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6373 if ( i+2 >= colors.count() ) break; // format error
6374 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6375 if ( i+3 >= colors.count() ) break; // format error
6376 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6377 elem0dColor.setRgbF( r, g, b );
6380 else if ( type == "ball" ) {
6381 // ball color is set by 3 values r:g:b, where
6382 // - r,g,b - is rgb color components
6383 if ( i+1 >= colors.count() ) break; // format error
6384 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6385 if ( i+2 >= colors.count() ) break; // format error
6386 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6387 if ( i+3 >= colors.count() ) break; // format error
6388 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6389 ballColor.setRgbF( r, g, b );
6392 else if ( type == "outline" ) {
6393 // outline color is set by 3 values r:g:b, where
6394 // - r,g,b - is rgb color components
6395 if ( i+1 >= colors.count() ) break; // format error
6396 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6397 if ( i+2 >= colors.count() ) break; // format error
6398 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6399 if ( i+3 >= colors.count() ) break; // format error
6400 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6401 outlineColor.setRgbF( r, g, b );
6404 else if ( type == "orientation" ) {
6405 // orientation color is set by 3 values r:g:b, where
6406 // - r,g,b - is rgb color components
6407 if ( i+1 >= colors.count() ) break; // format error
6408 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6409 if ( i+2 >= colors.count() ) break; // format error
6410 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 if ( i+3 >= colors.count() ) break; // format error
6412 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6413 orientationColor.setRgbF( r, g, b );
6418 if ( nodeColor.isValid() )
6419 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6421 if ( edgeColor.isValid() )
6422 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6424 if ( faceColor.isValid() )
6425 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6427 if ( volumeColor.isValid() )
6428 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6429 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6430 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6432 if ( elem0dColor.isValid() )
6433 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6435 if ( ballColor.isValid() )
6436 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6438 if ( outlineColor.isValid() )
6439 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6440 // orientation color
6441 if ( orientationColor.isValid() )
6442 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6445 else if (paramNameStr == "Sizes") {
6446 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6449 int outlineWidth = -1;
6450 int elem0dSize = -1;
6451 //int ballSize = -1;
6452 double ballDiameter = -1.0;
6453 double ballScale = -1.0;
6454 double shrinkSize = -1;
6455 double orientationSize = -1;
6456 bool orientation3d = false;
6457 for ( int i = 0; i < sizes.count(); i++ ) {
6458 QString type = sizes[i];
6459 if ( type == "line" ) {
6460 // line (wireframe) width is given as single integer value
6461 if ( i+1 >= sizes.count() ) break; // format error
6462 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6466 if ( type == "outline" ) {
6467 // outline width is given as single integer value
6468 if ( i+1 >= sizes.count() ) break; // format error
6469 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6473 else if ( type == "elem0d" ) {
6474 // 0d element size is given as single integer value
6475 if ( i+1 >= sizes.count() ) break; // format error
6476 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6480 else if ( type == "ball" ) {
6481 // balls are specified by two values: size:scale, where
6482 // - size - is a integer value specifying size
6483 // - scale - is a double value specifying scale factor
6484 if ( i+1 >= sizes.count() ) break; // format error
6485 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6486 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6487 if ( i+2 >= sizes.count() ) break; // format error
6488 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6494 else if ( type == "shrink" ) {
6495 // shrink factor is given as single floating point value
6496 if ( i+1 >= sizes.count() ) break; // format error
6497 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6501 else if ( type == "orientation" ) {
6502 // orientation vectors are specified by two values size:3d, where
6503 // - size - is a floating point value specifying scale factor
6504 // - 3d - is a boolean
6505 if ( i+1 >= sizes.count() ) break; // format error
6506 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6507 if ( i+2 >= sizes.count() ) break; // format error
6508 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6509 orientationSize = v1;
6510 orientation3d = (bool)v2;
6514 // line (wireframe) width
6515 if ( lineWidth > 0 )
6516 aSmeshActor->SetLineWidth( lineWidth );
6518 if ( outlineWidth > 0 )
6519 aSmeshActor->SetOutlineWidth( outlineWidth );
6520 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6521 aSmeshActor->SetOutlineWidth( lineWidth );
6523 if ( elem0dSize > 0 )
6524 aSmeshActor->Set0DSize( elem0dSize );
6526 /*if ( ballSize > 0 )
6527 aSmeshActor->SetBallSize( ballSize );*/
6529 if ( ballDiameter > 0 )
6530 aSmeshActor->SetBallSize( ballDiameter );
6532 if ( ballScale > 0.0 )
6533 aSmeshActor->SetBallScale( ballScale );
6535 if ( shrinkSize > 0 )
6536 aSmeshActor->SetShrinkFactor( shrinkSize );
6537 // orientation vectors
6538 if ( orientationSize > 0 ) {
6539 aSmeshActor->SetFacesOrientationScale( orientationSize );
6540 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6544 else if (paramNameStr == "PointMarker") {
6545 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6546 if( data.count() >= 2 ) {
6548 int aParam1 = data[1].toInt( &ok );
6550 if( data[0] == "std" && data.count() == 3 ) {
6551 int aParam2 = data[2].toInt( &ok );
6552 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6554 else if( data[0] == "custom" ) {
6555 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6556 if( markerIt != aMarkerMap.end() ) {
6557 VTK::MarkerData aMarkerData = markerIt->second;
6558 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6565 else if (paramNameStr == "Opacity") {
6566 aSmeshActor->SetOpacity(val.toFloat());
6569 else if (paramNameStr.startsWith("ClippingPlane")) {
6570 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6571 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6572 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6573 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6574 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6575 // new format - val looks like "Off" or "0" (plane id)
6576 // (note: in new format "Off" value is used only for consistency,
6577 // so it is processed together with values in old format)
6578 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6579 if( anIsOldFormat ) {
6580 if (paramNameStr == "ClippingPlane1" || val == "Off")
6581 aSmeshActor->RemoveAllClippingPlanes();
6583 QList<SUIT_ViewManager*> lst;
6584 getApp()->viewManagers(viewerTypStr, lst);
6585 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6586 if (viewIndex >= 0 && viewIndex < lst.count()) {
6587 SUIT_ViewManager* vman = lst.at(viewIndex);
6588 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6590 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6592 SMESH::TActorList anActorList;
6593 anActorList.push_back( aSmeshActor );
6594 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6595 aPlane->myViewWindow = vtkView;
6596 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6597 aPlane->PlaneMode = aMode;
6598 bool isOpenGLClipping = ( bool )vals[1].toInt();
6599 aPlane->IsOpenGLClipping = isOpenGLClipping;
6600 if ( aMode == SMESH::Absolute ) {
6601 aPlane->myAbsoluteOrientation = vals[2].toInt();
6602 aPlane->X = vals[3].toFloat();
6603 aPlane->Y = vals[4].toFloat();
6604 aPlane->Z = vals[5].toFloat();
6605 aPlane->Dx = vals[6].toFloat();
6606 aPlane->Dy = vals[7].toFloat();
6607 aPlane->Dz = vals[8].toFloat();
6609 else if ( aMode == SMESH::Relative ) {
6610 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6611 aPlane->myDistance = vals[3].toFloat();
6612 aPlane->myAngle[0] = vals[4].toFloat();
6613 aPlane->myAngle[1] = vals[5].toFloat();
6617 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6618 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6619 aClippingPlaneInfo.Plane = aPlane;
6620 aClippingPlaneInfo.ActorList = anActorList;
6621 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6629 int aPlaneId = val.toInt( &ok );
6630 if( ok && aPlaneId >= 0 ) {
6631 bool anIsDefinedPlane = false;
6632 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6633 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6634 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6635 TPlaneInfo& aPlaneInfo = *anIter;
6636 if( aPlaneInfo.PlaneId == aPlaneId ) {
6637 aPlaneInfo.ActorList.push_back( aSmeshActor );
6638 anIsDefinedPlane = true;
6642 if( !anIsDefinedPlane ) {
6643 TPlaneInfo aPlaneInfo;
6644 aPlaneInfo.PlaneId = aPlaneId;
6645 aPlaneInfo.ActorList.push_back( aSmeshActor );
6646 aPlaneInfo.ViewManager = vman;
6648 // to make the list sorted by plane id
6649 anIter = aPlaneInfoList.begin();
6650 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6651 const TPlaneInfo& aPlaneInfoRef = *anIter;
6652 if( aPlaneInfoRef.PlaneId > aPlaneId )
6655 aPlaneInfoList.insert( anIter, aPlaneInfo );
6660 } // if (aSmeshActor)
6661 } // other parameters than Visibility
6663 } // for names/parameters iterator
6664 } // for entries iterator
6666 // take into account planes with empty list of actors referred to them
6667 QList<SUIT_ViewManager*> aVMList;
6668 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6670 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6671 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6672 int aViewId = aPlaneDataIter->first;
6673 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6674 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6676 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6678 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6679 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6680 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6681 const TPlaneData& aPlaneData = *anIter2;
6682 int aPlaneId = aPlaneData.Id;
6684 bool anIsFound = false;
6685 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6686 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6687 const TPlaneInfo& aPlaneInfo = *anIter3;
6688 if( aPlaneInfo.PlaneId == aPlaneId ) {
6695 TPlaneInfo aPlaneInfo; // ActorList field is empty
6696 aPlaneInfo.PlaneId = aPlaneId;
6697 aPlaneInfo.ViewManager = aViewManager;
6699 // to make the list sorted by plane id
6700 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6701 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6702 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6703 if( aPlaneInfoRef.PlaneId > aPlaneId )
6706 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6712 // add clipping planes to actors according to the restored parameters
6713 // and update the clipping plane map
6714 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6715 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6716 int aViewId = anIter1->first;
6717 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6719 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6720 if( anIter2 == aPlaneDataMap.end() )
6722 const TPlaneDataList& aPlaneDataList = anIter2->second;
6724 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6725 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6726 const TPlaneInfo& aPlaneInfo = *anIter3;
6727 int aPlaneId = aPlaneInfo.PlaneId;
6728 const TActorList& anActorList = aPlaneInfo.ActorList;
6729 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6733 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6737 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6739 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6740 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6741 const TPlaneData& aPlaneData = *anIter4;
6742 if( aPlaneData.Id == aPlaneId ) {
6743 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6744 aPlane->myViewWindow = aViewWindow;
6745 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6746 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6747 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6748 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6749 aPlane->X = aPlaneData.X;
6750 aPlane->Y = aPlaneData.Y;
6751 aPlane->Z = aPlaneData.Z;
6752 aPlane->Dx = aPlaneData.Dx;
6753 aPlane->Dy = aPlaneData.Dy;
6754 aPlane->Dz = aPlaneData.Dz;
6756 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6757 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6758 aPlane->myDistance = aPlaneData.Distance;
6759 aPlane->myAngle[0] = aPlaneData.Angle[0];
6760 aPlane->myAngle[1] = aPlaneData.Angle[1];
6763 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6764 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6765 aClippingPlaneInfo.Plane = aPlane;
6766 aClippingPlaneInfo.ActorList = anActorList;
6767 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6778 // update all VTK views
6779 QList<SUIT_ViewManager*> lst;
6780 getApp()->viewManagers(lst);
6781 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6782 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6783 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6784 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6785 // set OpenGL clipping planes
6786 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6787 vtkActorCollection* anAllActors = aCopy.GetActors();
6788 anAllActors->InitTraversal();
6789 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6790 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6791 anActor->SetOpenGLClippingPlane();
6793 vtkView->getRenderer()->ResetCameraClippingRange();
6800 \brief Adds preferences for dfont of VTK viewer
6802 \param pIf group identifier
6803 \param param parameter
6804 \return identifier of preferences
6806 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6808 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6810 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6813 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6814 fam.append( tr( "SMESH_FONT_COURIER" ) );
6815 fam.append( tr( "SMESH_FONT_TIMES" ) );
6817 setPreferenceProperty( tfont, "fonts", fam );
6819 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6820 if ( needSize ) f = f | QtxFontEdit::Size;
6821 setPreferenceProperty( tfont, "features", f );
6827 \brief Actions after hypothesis edition
6828 Updates object browser after hypothesis edition
6830 void SMESHGUI::onHypothesisEdit( int result )
6833 SMESHGUI::Modified();
6834 updateObjBrowser( true );
6839 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6840 \param pview view being closed
6842 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6843 #ifndef DISABLE_PLOT2DVIEWER
6844 //Crear all Plot2d Viewers if need.
6845 SMESH::ClearPlot2Viewers(pview);
6847 EmitSignalCloseView();
6850 void SMESHGUI::message( const QString& msg )
6853 QStringList data = msg.split("/");
6854 if ( data.count() > 0 ) {
6855 if ( data.first() == "mesh_loading" ) {
6857 QString entry = data.count() > 1 ? data[1] : QString();
6858 if ( entry.isEmpty() )
6861 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6863 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6866 name = SMESH::fromUtf8(obj->GetName());
6867 if ( name.isEmpty() )
6870 if ( data.last() == "stop" )
6871 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6873 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6874 QApplication::processEvents();
6880 \brief Connects or disconnects signals about activating and cloning view on the module slots
6881 \param pview view which is connected/disconnected
6883 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6887 SUIT_ViewManager* viewMgr = pview->getViewManager();
6889 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6890 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6892 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6893 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6898 \brief Return \c true if object can be renamed
6900 bool SMESHGUI::renameAllowed( const QString& entry) const {
6901 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6905 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6909 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6914 if(appStudy->isComponent(entry) || obj->isReference())
6917 // check type to prevent renaming of inappropriate objects
6918 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6919 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6920 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6921 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6922 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6923 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6930 Rename object by entry.
6931 \param entry entry of the object
6932 \param name new name of the object
6933 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6935 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6937 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6941 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6946 _PTR(Study) aStudy = appStudy->studyDS();
6951 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6953 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6958 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6959 _PTR(GenericAttribute) anAttr;
6960 _PTR(AttributeName) aName;
6962 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6964 // check type to prevent renaming of inappropriate objects
6965 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6966 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6967 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6968 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6969 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6970 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6971 if ( !name.isEmpty() ) {
6972 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6974 // update name of group object and its actor
6975 Handle(SALOME_InteractiveObject) IObject =
6976 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6978 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6979 if( !aGroupObject->_is_nil() ) {
6980 aGroupObject->SetName( qPrintable(name) );
6981 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6982 anActor->setName( qPrintable(name) );
6992 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6994 static QList<QColor> colors;
6996 if ( colors.isEmpty() ) {
6998 for (int s = 0; s < 2 ; s++)
7000 for (int v = 100; v >= 40; v = v - 20)
7002 for (int h = 0; h < 359 ; h = h + 60)
7004 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7009 static int currentColor = randomize( colors.size() );
7011 SALOMEDS::Color color;
7012 color.R = (double)colors[currentColor].red() / 255.0;
7013 color.G = (double)colors[currentColor].green() / 255.0;
7014 color.B = (double)colors[currentColor].blue() / 255.0;
7016 currentColor = (currentColor+1) % colors.count();