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 // actually, the following condition can't be met (added for insurance)
438 if( selected.Extent() == 0 ||
439 ( selected.Extent() > 1 && !isMED && !isSTL ))
442 // get mesh object from selection and check duplication of their names
443 bool hasDuplicatedMeshNames = false;
444 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
445 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
446 SALOME_ListIteratorOfListIO It( selected );
447 for( ; It.More(); It.Next() )
449 Handle(SALOME_InteractiveObject) anIObject = It.Value();
450 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
451 if ( aMeshItem->_is_nil() ) {
452 SUIT_MessageBox::warning( SMESHGUI::desktop(),
453 QObject::tr( "SMESH_WRN_WARNING" ),
454 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
458 QString aMeshName = anIObject->getName();
460 // check for name duplications
461 if ( !hasDuplicatedMeshNames )
462 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
463 if( aMeshName == (*aMeshIter).second ) {
464 hasDuplicatedMeshNames = true;
469 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
472 if( hasDuplicatedMeshNames && isMED ) {
473 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
474 QObject::tr("SMESH_WRN_WARNING"),
475 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
476 QObject::tr("SMESH_BUT_YES"),
477 QObject::tr("SMESH_BUT_NO"), 0, 1);
482 aMeshIter = aMeshList.begin();
483 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
484 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
485 QString aMeshName = (*aMeshIter).second;
487 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
489 // check for equal group names within each mesh
490 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
491 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
492 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
493 int aRet = SUIT_MessageBox::warning
494 (SMESHGUI::desktop(),
495 QObject::tr("SMESH_WRN_WARNING"),
496 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
497 QObject::tr("SMESH_BUT_YES"),
498 QObject::tr("SMESH_BUT_NO"), 0, 1);
505 // Warn the user about presence of not supported elements
507 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
511 notSupportedElemTypes.push_back( SMESH::Entity_0D );
512 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
517 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
518 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
519 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
520 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
521 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
522 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
523 notSupportedElemTypes.push_back( SMESH::Entity_0D );
524 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
529 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
530 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
531 notSupportedElemTypes.push_back( SMESH::Entity_0D );
532 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
537 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
538 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
543 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
544 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
545 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
546 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
547 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
548 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
549 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
554 notSupportedElemTypes.push_back( SMESH::Entity_0D );
555 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
559 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
560 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
564 if ( ! notSupportedElemTypes.empty() )
566 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
567 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
568 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
569 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
571 if ( !presentNotSupported.empty() )
574 const char* typeMsg[SMESH::Entity_Last] = {
575 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
576 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
577 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
578 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
579 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
580 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
581 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
582 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
584 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
585 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
586 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
587 if ( iType != presentNotSupported.size() - 1 )
588 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
590 int aRet = SUIT_MessageBox::warning
591 (SMESHGUI::desktop(),
592 QObject::tr("SMESH_WRN_WARNING"),
593 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
594 QObject::tr("SMESH_BUT_YES"),
595 QObject::tr("SMESH_BUT_NO"), 0, 1);
600 // Get parameters of export operation
603 SMESH::MED_VERSION aFormat;
604 // Init the parameters with the default values
605 bool aIsASCII_STL = true;
606 bool toCreateGroups = false;
607 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
609 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
610 bool toOverwrite = true;
611 bool toFindOutDim = true;
613 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
614 QString anInitialPath = "";
615 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
616 anInitialPath = QDir::currentPath();
618 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
620 // Get a file name to write in and additional otions
621 if ( isUNV || isDAT || isGMF ) // Export w/o options
624 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
626 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
628 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
629 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
630 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
631 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
632 anInitialPath + QString("/") + aMeshName,
633 aFilter, aTitle, false);
635 else if ( isCGNS )// Export to CGNS
637 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
638 fd->setWindowTitle( aTitle );
639 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
640 if ( !anInitialPath.isEmpty() )
641 fd->setDirectory( anInitialPath );
642 fd->selectFile(aMeshName);
643 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
644 fd->setValidator( fv );
647 aFilename = fd->selectedFile();
648 toOverwrite = fv->isOverwrite();
652 else if ( isSTL ) // Export to STL
654 QMap<QString, int> aFilterMap;
655 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
656 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
659 QMap<QString, int>::const_iterator it = aFilterMap.begin();
660 for ( ; it != aFilterMap.end(); ++it )
661 filters.push_back( it.key() );
663 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
664 fd->setWindowTitle( aTitle );
665 fd->setNameFilters( filters );
666 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
667 if ( !anInitialPath.isEmpty() )
668 fd->setDirectory( anInitialPath );
669 fd->selectFile(aMeshName);
673 aFilename = fd->selectedFile();
674 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
679 else if ( isMED || isSAUV ) // Export to MED or SAUV
681 QMap<QString, SMESH::MED_VERSION> aFilterMap;
682 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
684 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
685 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
686 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
689 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
690 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
691 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
695 QString aDefaultFilter;
696 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
697 for ( ; it != aFilterMap.end(); ++it ) {
698 filters.push_back( it.key() );
699 if (it.value() == SMESH::MED_V2_2)
700 aDefaultFilter = it.key();
702 QStringList checkBoxes;
703 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
705 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
706 QList< QWidget* > wdgList;
707 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
708 wdgList.append( fieldSelWdg );
710 SalomeApp_CheckFileDlg* fd =
711 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
712 fd->setWindowTitle( aTitle );
713 fd->setNameFilters( filters );
714 fd->selectNameFilter( aDefaultFilter );
715 fd->SetChecked( toCreateGroups, 0 );
716 fd->SetChecked( toFindOutDim, 1 );
717 if ( !anInitialPath.isEmpty() )
718 fd->setDirectory( anInitialPath );
719 fd->selectFile(aMeshName);
722 QListView *lview = fd->findChild<QListView*>("listView");
724 lview->setMinimumHeight(200);
726 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
728 tview->setMinimumHeight(200);
731 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
732 fd->setValidator( fv );
737 aFilename = fd->selectedFile();
739 aFilename = QString::null;
742 aFormat = aFilterMap[fd->selectedNameFilter()];
743 toOverwrite = fv->isOverwrite();
745 if ( !aFilename.isEmpty() ) {
746 // med-2.1 does not support poly elements
747 if ( aFormat==SMESH::MED_V2_1 )
748 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
749 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
750 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
751 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
752 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
754 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
755 QObject::tr("SMESH_WRN_WARNING"),
756 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
757 QObject::tr("SMESH_BUT_YES"),
758 QObject::tr("SMESH_BUT_NO"), 0, 1);
766 // can't append to an existing using other format
767 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
768 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
769 if( !isVersionOk || aVersion != aFormat ) {
770 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
771 QObject::tr("SMESH_WRN_WARNING"),
772 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
773 QObject::tr("SMESH_BUT_YES"),
774 QObject::tr("SMESH_BUT_NO"), 0, 1);
781 QStringList aMeshNamesCollisionList;
782 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
783 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
784 QString anExistingMeshName( aMeshNames[ i ] );
785 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
786 QString anExportMeshName = (*aMeshIter).second;
787 if( anExportMeshName == anExistingMeshName ) {
788 aMeshNamesCollisionList.append( anExportMeshName );
793 if( !aMeshNamesCollisionList.isEmpty() ) {
794 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
795 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
796 QObject::tr("SMESH_WRN_WARNING"),
797 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
798 QObject::tr("SMESH_BUT_YES"),
799 QObject::tr("SMESH_BUT_NO"),
800 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
809 toCreateGroups = fd->IsChecked(0);
810 toFindOutDim = fd->IsChecked(1);
811 fieldSelWdg->GetSelectedFeilds();
812 if ( !fieldSelWdg->parent() )
823 if ( !aFilename.isEmpty() ) {
824 // Check whether the file already exists and delete it if yes
825 QFile aFile( aFilename );
826 if ( aFile.exists() && toOverwrite )
828 SUIT_OverrideCursor wc;
831 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
832 // bool Renumber = false;
833 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
835 // Renumber= resMgr->booleanValue("renumbering");
837 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
838 // aMeshEditor->RenumberNodes();
839 // aMeshEditor->RenumberElements();
840 // if ( SMESHGUI::automaticUpdate() )
841 // SMESH::UpdateView();
845 aMeshIter = aMeshList.begin();
846 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
848 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
849 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
850 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
851 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
852 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
853 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
854 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
855 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
857 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
858 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
859 fields, geoAssFields.toLatin1().data() );
864 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
866 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
867 if( !aMeshItem->_is_nil() )
868 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
873 if ( aMeshOrGroup->_is_equivalent( aMesh ))
874 aMesh->ExportDAT( aFilename.toUtf8().data() );
876 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
880 if ( aMeshOrGroup->_is_equivalent( aMesh ))
881 aMesh->ExportUNV( aFilename.toUtf8().data() );
883 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
887 if ( aMeshOrGroup->_is_equivalent( aMesh ))
888 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
890 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
894 aMeshIter = aMeshList.begin();
895 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
897 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
898 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
899 aMeshItem->ExportCGNS( aMeshOrGroup,
900 aFilename.toUtf8().data(),
901 toOverwrite && aMeshIndex == 0 );
906 toCreateGroups = true;
907 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
910 catch (const SALOME::SALOME_Exception& S_ex){
912 SUIT_MessageBox::warning(SMESHGUI::desktop(),
913 QObject::tr("SMESH_WRN_WARNING"),
914 QObject::tr("SMESH_EXPORT_FAILED"));
920 inline void InverseEntityMode(unsigned int& theOutputMode,
921 unsigned int theMode)
923 bool anIsNotPresent = ~theOutputMode & theMode;
925 theOutputMode |= theMode;
927 theOutputMode &= ~theMode;
930 void SetDisplayEntity(int theCommandID){
931 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
932 SALOME_ListIO selected;
934 aSel->selectedObjects( selected );
936 if(selected.Extent() >= 1){
937 SALOME_ListIteratorOfListIO It( selected );
938 for( ; It.More(); It.Next()){
939 Handle(SALOME_InteractiveObject) IObject = It.Value();
940 if(IObject->hasEntry()){
941 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
942 unsigned int aMode = anActor->GetEntityMode();
943 switch(theCommandID){
944 case SMESHOp::OpDE0DElements:
945 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
947 case SMESHOp::OpDEEdges:
948 InverseEntityMode(aMode,SMESH_Actor::eEdges);
950 case SMESHOp::OpDEFaces:
951 InverseEntityMode(aMode,SMESH_Actor::eFaces);
953 case SMESHOp::OpDEVolumes:
954 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
956 case SMESHOp::OpDEBalls:
957 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
959 case SMESHOp::OpDEAllEntity:
960 aMode = SMESH_Actor::eAllEntity;
964 anActor->SetEntityMode(aMode);
973 SALOME_ListIO selected;
974 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
978 LightApp_SelectionMgr* aSel = app->selectionMgr();
979 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
980 if( !aSel || !appStudy )
983 aSel->selectedObjects( selected );
984 if( selected.IsEmpty() )
987 Handle(SALOME_InteractiveObject) anIObject = selected.First();
989 _PTR(Study) aStudy = appStudy->studyDS();
990 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
991 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
992 if( aMainObject->_is_nil() )
995 SUIT_OverrideCursor wc;
997 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
999 QList<SALOMEDS::Color> aReservedColors;
1001 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1002 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1004 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1005 //SALOMEDS::Color aColor = aGroupObject->GetColor();
1007 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1008 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1009 #else // old algorithm for auto-colors
1010 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1011 aReservedColors.append( aColor );
1012 #endif // SIMPLE_AUTOCOLOR
1013 aGroupObject->SetColor( aColor );
1015 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1016 if (aGroupSObject) {
1019 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1020 switch ( aGroupObject->GetType ()) {
1022 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1024 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1026 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1028 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1030 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1031 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1034 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1035 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1041 SMESH::RepaintCurrentView();
1044 void OverallMeshQuality() {
1045 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1046 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1047 SALOME_ListIO selected;
1049 aSel->selectedObjects( selected );
1051 if ( selected.IsEmpty() ) return;
1052 SALOME_ListIteratorOfListIO It( selected );
1053 for ( ; It.More(); It.Next() ) {
1054 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1055 ctrlDlg->showInfo( It.Value() );
1060 QString functorToString( SMESH::Controls::FunctorPtr f )
1062 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1063 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1064 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1065 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1066 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1067 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1068 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1069 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1070 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1071 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1072 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1073 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1074 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1075 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1076 type = QObject::tr( "WARP_ELEMENTS" );
1077 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1078 type = QObject::tr( "TAPER_ELEMENTS" );
1079 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1080 type = QObject::tr( "SKEW_ELEMENTS" );
1081 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1082 type = QObject::tr( "AREA_ELEMENTS" );
1083 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1084 type = QObject::tr( "LENGTH_EDGES" );
1085 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1086 type = QObject::tr( "LENGTH2D_EDGES" );
1087 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1088 type = QObject::tr( "MULTI_BORDERS" );
1089 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1090 type = QObject::tr( "MULTI2D_BORDERS" );
1091 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1092 type = QObject::tr( "FREE_NODES" );
1093 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1094 type = QObject::tr( "FREE_EDGES" );
1095 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1096 type = QObject::tr( "FREE_BORDERS" );
1097 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1098 type = QObject::tr( "FREE_FACES" );
1099 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1100 type = QObject::tr( "BARE_BORDER_VOLUME" );
1101 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1102 type = QObject::tr( "BARE_BORDER_FACE" );
1103 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1104 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1105 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1106 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1107 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1108 type = QObject::tr( "EQUAL_NODE" );
1109 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1110 type = QObject::tr( "EQUAL_EDGE" );
1111 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1112 type = QObject::tr( "EQUAL_FACE" );
1113 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1114 type = QObject::tr( "EQUAL_VOLUME" );
1118 void SaveDistribution()
1120 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1121 SALOME_ListIO selected;
1123 aSel->selectedObjects( selected );
1125 if ( selected.Extent() == 1 ) {
1126 Handle(SALOME_InteractiveObject) anIO = selected.First();
1127 if ( anIO->hasEntry() ) {
1128 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1129 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1130 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1131 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1132 if ( aScalarBarActor && aFunctor ) {
1133 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1135 std::vector<int> elements;
1136 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1137 if ( mesh->_is_nil() ) {
1138 SMESH::SMESH_IDSource_var idSource =
1139 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1140 if ( !idSource->_is_nil() )
1142 SMESH::long_array_var ids = idSource->GetIDs();
1143 elements.resize( ids->length() );
1144 for ( unsigned i = 0; i < elements.size(); ++i )
1145 elements[i] = ids[i];
1148 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1149 vtkLookupTable* lookupTable =
1150 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1151 double * minmax = lookupTable->GetRange();
1152 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1153 std::vector<int> nbEvents;
1154 std::vector<double> funValues;
1155 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1156 QString anInitialPath = "";
1157 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1158 anInitialPath = QDir::currentPath();
1159 QString aMeshName = anIO->getName();
1161 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1162 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1163 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1164 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1165 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1168 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1170 if ( !aFilename.isEmpty() ) {
1171 QFile f( aFilename );
1172 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1173 QTextStream out( &f );
1174 out << "# Mesh: " << aMeshName << endl;
1175 out << "# Control: " << functorToString( aFunctor ) << endl;
1177 out.setFieldWidth( 10 );
1178 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1179 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1190 void ShowElement(int theCommandID ) {
1191 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1192 SALOME_ListIO selected;
1194 aSel->selectedObjects( selected );
1196 if ( selected.Extent() == 1 ) {
1197 Handle(SALOME_InteractiveObject) anIO = selected.First();
1198 if ( anIO->hasEntry() ) {
1199 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1200 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1201 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1202 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1203 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1205 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1206 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1213 #ifndef DISABLE_PLOT2DVIEWER
1214 void PlotDistribution() {
1215 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1219 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1220 SALOME_ListIO selected;
1222 aSel->selectedObjects( selected );
1224 if ( selected.Extent() == 1 ) {
1225 Handle(SALOME_InteractiveObject) anIO = selected.First();
1226 if ( anIO->hasEntry() ) {
1227 //Find Actor by entry before getting Plot2d viewer,
1228 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1229 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1231 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1236 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1240 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1244 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1245 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1246 QString functorName = functorToString( anActor->GetFunctor());
1247 QString aHistogramName("%1 : %2");
1248 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1249 aHistogram->setName(aHistogramName);
1250 aHistogram->setHorTitle(functorName);
1251 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1252 aPlot->displayObject(aHistogram, true);
1257 #endif //DISABLE_PLOT2DVIEWER
1259 void DisableAutoColor(){
1260 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1261 SALOME_ListIO selected;
1263 aSel->selectedObjects( selected );
1265 if(selected.Extent()){
1266 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1267 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1268 if ( !aMesh->_is_nil() ) {
1269 aMesh->SetAutoColor( false );
1274 void sortChildren(){
1275 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1276 SALOME_ListIO selected;
1278 aSel->selectedObjects( selected );
1280 if(selected.Extent()){
1281 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1282 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1283 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1285 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1286 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1293 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1295 SALOME_ListIO selected;
1296 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1300 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1301 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1302 if( !aSel || !appStudy )
1305 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1306 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1307 aModule->EmitSignalDeactivateDialog();
1308 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1309 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1314 _PTR(Study) aStudy = appStudy->studyDS();
1316 aSel->selectedObjects( selected );
1318 if(selected.Extent() >= 1){
1319 switch(theCommandID){
1320 case SMESHOp::OpTransparency:{
1321 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1322 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1325 case SMESHOp::OpProperties: {
1327 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1328 QColor orientationColor, outlineColor, volumeColor;
1329 int deltaF = 0, deltaV = 0;
1332 double ballScale = 1.0;
1334 int outlineWidth = 1;
1335 double shrinkCoef = 0.0;
1336 double orientationScale = 0.0;
1337 bool orientation3d = false;
1338 VTK::MarkerType markerType = VTK::MT_NONE;
1339 VTK::MarkerScale markerScale = VTK::MS_NONE;
1341 bool hasNodes = false;
1342 int presentEntities = 0;
1343 bool firstTime = true;
1345 SALOME_ListIteratorOfListIO It( selected );
1346 for ( ; It.More(); It.Next() ) {
1347 Handle(SALOME_InteractiveObject) IObject = It.Value();
1348 if ( !IObject->hasEntry() ) continue;
1349 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1350 if ( !anActor || !anActor->GetObject() ) continue;
1353 // nodes: color, marker
1354 anActor->GetNodeColor( color[0], color[1], color[2] );
1355 nodeColor.setRgbF( color[0], color[1], color[2] );
1356 markerType = anActor->GetMarkerType();
1357 markerScale = anActor->GetMarkerScale();
1358 markerId = anActor->GetMarkerTexture();
1359 // edges: color, width
1360 anActor->GetEdgeColor( color[0], color[1], color[2] );
1361 edgeColor.setRgbF( color[0], color[1], color[2] );
1362 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1363 // faces: front color, back color (delta)
1364 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1365 faceColor.setRgbF( color[0], color[1], color[2] );
1366 // faces: front color, back color (delta)
1367 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1368 volumeColor.setRgbF( color[0], color[1], color[2] );
1369 // 0d elements: color, size
1370 anActor->Get0DColor( color[0], color[1], color[2] );
1371 elem0dColor.setRgbF( color[0], color[1], color[2] );
1372 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1373 // balls: color, size
1374 anActor->GetBallColor( color[0], color[1], color[2] );
1375 ballColor.setRgbF( color[0], color[1], color[2] );
1376 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1377 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1379 anActor->GetOutlineColor( color[0], color[1], color[2] );
1380 outlineColor.setRgbF( color[0], color[1], color[2] );
1381 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1382 // orientation vectors: color, scale, 3d flag
1383 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1384 orientationColor.setRgbF( color[0], color[1], color[2] );
1385 orientationScale = anActor->GetFacesOrientationScale();
1386 orientation3d = anActor->GetFacesOrientation3DVectors();
1388 shrinkCoef = anActor->GetShrinkFactor();
1391 firstTime = false; // we only take properties from first object (for performance reasons)
1394 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1395 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1396 presentEntities = presentEntities | SMESH_Actor::eEdges;
1397 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1398 presentEntities = presentEntities | SMESH_Actor::eFaces;
1399 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1400 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1401 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1402 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1403 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1404 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1406 // as we know that all types of elements are present, we can exit the loop
1407 if ( presentEntities == SMESH_Actor::eAllEntity )
1411 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1412 // nodes: color, marker
1413 dlg.setNodeColor( nodeColor );
1414 if( markerType != VTK::MT_USER )
1415 dlg.setNodeMarker( markerType, markerScale );
1417 dlg.setNodeCustomMarker( markerId );
1418 // edges: color, line width
1419 dlg.setEdgeColor( edgeColor );
1420 dlg.setEdgeWidth( edgeWidth );
1421 // faces: front color, back color
1422 dlg.setFaceColor( faceColor, deltaF );
1423 // volumes: normal color, reversed color
1424 dlg.setVolumeColor( volumeColor, deltaV );
1425 // outlines: color, line width
1426 dlg.setOutlineColor( outlineColor );
1427 dlg.setOutlineWidth( outlineWidth );
1428 // 0d elements: color, size
1429 dlg.setElem0dColor( elem0dColor );
1430 dlg.setElem0dSize( elem0dSize );
1431 // balls: color, size
1432 dlg.setBallColor( ballColor );
1433 //dlg.setBallSize( ballSize );
1434 dlg.setBallScale( ballScale );
1435 // orientation: color, scale, 3d flag
1436 dlg.setOrientationColor( orientationColor );
1437 dlg.setOrientationSize( int( orientationScale * 100. ) );
1438 dlg.setOrientation3d( orientation3d );
1439 // shrink: scale factor
1440 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1441 // hide unused controls
1442 dlg.showControls( presentEntities, hasNodes );
1445 nodeColor = dlg.nodeColor();
1446 markerType = dlg.nodeMarkerType();
1447 markerScale = dlg.nodeMarkerScale();
1448 markerId = dlg.nodeMarkerId();
1449 edgeColor = dlg.edgeColor();
1450 edgeWidth = dlg.edgeWidth();
1451 faceColor = dlg.faceColor();
1452 deltaF = dlg.faceColorDelta();
1453 volumeColor = dlg.volumeColor();
1454 deltaV = dlg.volumeColorDelta();
1455 outlineColor = dlg.outlineColor();
1456 outlineWidth = dlg.outlineWidth();
1457 elem0dColor = dlg.elem0dColor();
1458 elem0dSize = dlg.elem0dSize();
1459 ballColor = dlg.ballColor();
1460 // ballSize = dlg.ballSize();
1461 ballScale = dlg.ballScale();
1462 orientationColor = dlg.orientationColor();
1463 orientationScale = dlg.orientationSize() / 100.;
1464 orientation3d = dlg.orientation3d();
1465 shrinkCoef = dlg.shrinkCoef() / 100.;
1467 // store point markers map that might be changed by the user
1468 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1470 // set properties from dialog box to the presentations
1471 SALOME_ListIteratorOfListIO It( selected );
1472 for ( ; It.More(); It.Next() ) {
1473 Handle(SALOME_InteractiveObject) IObject = It.Value();
1474 if ( !IObject->hasEntry() ) continue;
1475 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1476 if ( !anActor ) continue;
1478 // nodes: color, marker
1479 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1480 if ( markerType != VTK::MT_USER ) {
1481 anActor->SetMarkerStd( markerType, markerScale );
1484 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1485 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1486 if ( iter != markerMap.end() )
1487 anActor->SetMarkerTexture( markerId, iter->second.second );
1489 // volumes: normal color, reversed color (delta)
1490 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1491 // faces: front color, back color (delta)
1492 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1493 // edges: color, width
1494 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1495 anActor->SetLineWidth( edgeWidth );
1497 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1498 anActor->SetOutlineWidth( outlineWidth );
1499 // 0D elements: color, size
1500 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1501 anActor->Set0DSize( elem0dSize );
1502 // balls: color, size
1503 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1504 // anActor->SetBallSize( ballSize );
1505 anActor->SetBallScale( ballScale );
1506 // orientation: color, scale, 3d flag
1507 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1508 anActor->SetFacesOrientationScale( orientationScale );
1509 anActor->SetFacesOrientation3DVectors( orientation3d );
1511 anActor->SetShrinkFactor( shrinkCoef );
1513 // for groups, set also proper color
1514 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1515 if ( !aGroupObject->_is_nil() ) {
1516 SMESH::ElementType anElementType = aGroupObject->GetType();
1518 switch( anElementType ) {
1520 aColor = nodeColor; break;
1522 aColor = edgeColor; break;
1524 aColor = faceColor; break;
1526 aColor = volumeColor; break;
1528 aColor = elem0dColor; break;
1530 aColor = ballColor; break;
1534 if ( aColor.isValid() ) {
1535 SALOMEDS::Color aGroupColor;
1536 aGroupColor.R = aColor.redF();
1537 aGroupColor.G = aColor.greenF();
1538 aGroupColor.B = aColor.blueF();
1539 aGroupObject->SetColor( aGroupColor );
1541 } // if ( !aGroupObject->_is_nil() )
1542 } // for ( ; It.More(); It.Next() )
1543 SMESH::RepaintCurrentView();
1544 } // if ( dlg.exec() )
1546 } // case SMESHOp::OpProperties:
1547 } // switch(theCommandID)
1548 SALOME_ListIteratorOfListIO It( selected );
1549 for( ; It.More(); It.Next()){
1550 Handle(SALOME_InteractiveObject) IObject = It.Value();
1551 if(IObject->hasEntry()){
1552 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1553 switch(theCommandID){
1554 case SMESHOp::OpDMWireframe:
1555 anActor->SetRepresentation(SMESH_Actor::eEdge);
1557 case SMESHOp::OpDMShading:
1558 anActor->SetRepresentation(SMESH_Actor::eSurface);
1560 case SMESHOp::OpDMShrink:
1561 if(anActor->IsShrunk())
1562 anActor->UnShrink();
1564 anActor->SetShrink();
1566 case SMESHOp::OpDMNodes:
1567 anActor->SetRepresentation(SMESH_Actor::ePoint);
1569 case SMESHOp::OpRepresentationLines:
1570 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1571 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1573 case SMESHOp::OpRepresentationArcs:
1574 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1575 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1581 SMESH::RepaintCurrentView();
1585 void Control( int theCommandID )
1587 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1588 switch ( theCommandID ){
1589 case SMESHOp::OpFreeNode:
1590 aControl = SMESH_Actor::eFreeNodes;
1592 case SMESHOp::OpEqualNode:
1593 aControl = SMESH_Actor::eCoincidentNodes;
1595 case SMESHOp::OpFreeEdge:
1596 aControl = SMESH_Actor::eFreeEdges;
1598 case SMESHOp::OpFreeBorder:
1599 aControl = SMESH_Actor::eFreeBorders;
1601 case SMESHOp::OpLength:
1602 aControl = SMESH_Actor::eLength;
1604 case SMESHOp::OpConnection:
1605 aControl = SMESH_Actor::eMultiConnection;
1607 case SMESHOp::OpEqualEdge:
1608 aControl = SMESH_Actor::eCoincidentElems1D;
1610 case SMESHOp::OpFreeFace:
1611 aControl = SMESH_Actor::eFreeFaces;
1613 case SMESHOp::OpBareBorderFace:
1614 aControl = SMESH_Actor::eBareBorderFace;
1616 case SMESHOp::OpOverConstrainedFace:
1617 aControl = SMESH_Actor::eOverConstrainedFace;
1619 case SMESHOp::OpLength2D:
1620 aControl = SMESH_Actor::eLength2D;
1622 case SMESHOp::OpConnection2D:
1623 aControl = SMESH_Actor::eMultiConnection2D;
1625 case SMESHOp::OpArea:
1626 aControl = SMESH_Actor::eArea;
1628 case SMESHOp::OpTaper:
1629 aControl = SMESH_Actor::eTaper;
1631 case SMESHOp::OpAspectRatio:
1632 aControl = SMESH_Actor::eAspectRatio;
1634 case SMESHOp::OpMinimumAngle:
1635 aControl = SMESH_Actor::eMinimumAngle;
1637 case SMESHOp::OpWarpingAngle:
1638 aControl = SMESH_Actor::eWarping;
1640 case SMESHOp::OpSkew:
1641 aControl = SMESH_Actor::eSkew;
1643 case SMESHOp::OpMaxElementLength2D:
1644 aControl = SMESH_Actor::eMaxElementLength2D;
1646 case SMESHOp::OpEqualFace:
1647 aControl = SMESH_Actor:: eCoincidentElems2D;
1649 case SMESHOp::OpAspectRatio3D:
1650 aControl = SMESH_Actor::eAspectRatio3D;
1652 case SMESHOp::OpVolume:
1653 aControl = SMESH_Actor::eVolume3D;
1655 case SMESHOp::OpMaxElementLength3D:
1656 aControl = SMESH_Actor::eMaxElementLength3D;
1658 case SMESHOp::OpBareBorderVolume:
1659 aControl = SMESH_Actor::eBareBorderVolume;
1661 case SMESHOp::OpOverConstrainedVolume:
1662 aControl = SMESH_Actor::eOverConstrainedVolume;
1664 case SMESHOp::OpEqualVolume:
1665 aControl = SMESH_Actor::eCoincidentElems3D;
1668 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1669 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1670 SALOME_ListIO selected;
1672 aSel->selectedObjects( selected );
1674 if( !selected.IsEmpty() ){
1675 SALOME_ListIteratorOfListIO It(selected);
1676 for ( ; It.More(); It.Next())
1678 Handle(SALOME_InteractiveObject) anIO = It.Value();
1680 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1682 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1683 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1684 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1685 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1686 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1687 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1688 anActor->SetControlMode(aControl);
1689 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1690 SMESH::RepaintCurrentView();
1691 #ifndef DISABLE_PLOT2DVIEWER
1692 if(anActor->GetPlot2Histogram()) {
1693 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1694 QString functorName = functorToString( anActor->GetFunctor());
1695 QString aHistogramName("%1 : %2");
1696 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1697 aHistogram->setName(aHistogramName);
1698 aHistogram->setHorTitle(functorName);
1699 SMESH::ProcessIn2DViewers(anActor);
1711 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1712 SMESH::MeshObjectType theType,
1713 const QString theInTypeName,
1714 QString & theOutTypeName)
1716 SMESH_TypeFilter aTypeFilter( theType );
1718 if( !theIO.IsNull() )
1720 entry = theIO->getEntry();
1721 LightApp_DataOwner owner( entry );
1722 if ( aTypeFilter.isOk( &owner )) {
1723 theOutTypeName = theInTypeName;
1731 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1733 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1734 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1736 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1737 CORBA::String_var anID = aSComp->GetID().c_str();
1738 if (!strcmp(anID.in(),theIO->getEntry()))
1744 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1745 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1746 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1747 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1748 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1756 QString CheckHomogeneousSelection()
1758 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1759 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1760 SALOME_ListIO selected;
1762 aSel->selectedObjects( selected );
1764 QString RefType = CheckTypeObject(selected.First());
1765 SALOME_ListIteratorOfListIO It(selected);
1766 for ( ; It.More(); It.Next())
1768 Handle(SALOME_InteractiveObject) IObject = It.Value();
1769 QString Type = CheckTypeObject(IObject);
1770 if (Type.compare(RefType) != 0)
1771 return "Heterogeneous Selection";
1777 uint randomize( uint size )
1779 static bool initialized = false;
1780 if ( !initialized ) {
1781 qsrand( QDateTime::currentDateTime().toTime_t() );
1785 v = uint( (double)( v ) / RAND_MAX * size );
1786 v = qMax( uint(0), qMin ( v, size-1 ) );
1792 void SMESHGUI::OnEditDelete()
1794 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1795 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1796 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1798 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1799 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1800 _PTR(GenericAttribute) anAttr;
1801 _PTR(AttributeIOR) anIOR;
1803 int objectCount = 0;
1805 QString aParentComponent = QString::null;
1806 Handle(SALOME_InteractiveObject) anIO;
1807 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1809 anIO = anIt.Value();
1810 QString cur = anIO->getComponentDataType();
1811 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1813 // check if object is reference
1814 _PTR(SObject) aRefSObj;
1815 aNameList.append("\n - ");
1816 if ( aSO->ReferencedObject( aRefSObj ) ) {
1817 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1818 aNameList.append( aRefName );
1819 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1822 aNameList.append(anIO->getName());
1826 if( aParentComponent.isNull() )
1827 aParentComponent = cur;
1828 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1829 aParentComponent = "";
1832 if ( objectCount == 0 )
1833 return; // No Valid Objects Selected
1835 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1836 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1837 QObject::tr("ERR_ERROR"),
1838 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1841 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1842 if (SUIT_MessageBox::warning
1843 (SMESHGUI::desktop(),
1844 QObject::tr("SMESH_WRN_WARNING"),
1845 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1846 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1847 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1850 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1852 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1853 // then treat them all starting from the deepest objects (at list back)
1854 std::list< _PTR(SObject) > listSO;
1855 SALOME_ListIteratorOfListIO It(selected);
1856 for( ; It.More(); It.Next()) // loop on selected IO's
1858 Handle(SALOME_InteractiveObject) IObject = It.Value();
1859 if(IObject->hasEntry()) {
1860 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1862 // disable removal of "SMESH" component object
1863 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1865 if ( engineIOR() == anIOR->Value().c_str() )
1868 //Check the referenced object
1869 _PTR(SObject) aRefSObject;
1870 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1871 aSO = aRefSObject; // Delete main Object instead of reference
1873 listSO.push_back( aSO );
1874 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1875 for ( ; itSO != listSO.end(); ++itSO ) {
1876 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1877 for (it->InitEx(false); it->More(); it->Next())
1878 listSO.push_back( it->Value() );
1882 // Check if none of objects to delete is referred from outside
1883 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1884 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1886 _PTR(SObject) SO = *ritSO;
1887 if ( !SO ) continue;
1888 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1889 for (size_t i = 0; i < aReferences.size(); i++) {
1890 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1891 std::string type = aComponent->ComponentDataType();
1892 if ( type != "SMESH" )
1894 SUIT_MessageBox::warning( anApp->desktop(),
1895 QObject::tr("WRN_WARNING"),
1896 QObject::tr("DEP_OBJECT") );
1897 return; // outside SMESH, there is an object depending on a SMESH object
1902 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1903 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1905 Handle(SALOME_InteractiveObject) IObject = It.Value();
1906 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1907 if ( !mesh->_is_nil() )
1911 // Treat SO's in the list starting from the back
1912 aStudyBuilder->NewCommand(); // There is a transaction
1913 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1915 _PTR(SObject) SO = *ritSO;
1916 if ( !SO ) continue;
1917 std::string anEntry = SO->GetID();
1919 /** Erase graphical object and remove all its data **/
1920 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1921 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1923 /** Remove an object from data structures **/
1924 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1925 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1926 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1927 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1928 aMesh->RemoveGroup( aGroup );
1930 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1931 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1932 aMesh->RemoveSubMesh( aSubMesh );
1934 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1936 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1939 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1940 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1941 QString objType = CheckTypeObject(IObject);
1942 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1943 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1944 aStudyBuilder->RemoveObjectWithChildren( SO );
1946 else {// default action: remove SObject from the study
1947 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1948 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1950 aStudyBuilder->RemoveObjectWithChildren( SO );
1954 } /* listSO back loop */
1956 aStudyBuilder->CommitCommand();
1958 /* Clear any previous selection */
1960 aSel->setSelectedObjects( l1 );
1962 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1966 SMESHGUI_EXPORT CAM_Module* createModule()
1968 return new SMESHGUI();
1971 SMESHGUI_EXPORT char* getModuleVersion() {
1972 return (char*)SMESH_VERSION_STR;
1976 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1978 //=============================================================================
1982 //=============================================================================
1983 SMESHGUI::SMESHGUI() :
1984 SalomeApp_Module( "SMESH" )
1986 if ( CORBA::is_nil( myComponentSMESH ) )
1988 CORBA::Boolean anIsEmbeddedMode;
1989 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1990 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1992 // 0019923: EDF 765 SMESH : default values of hypothesis
1993 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1994 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1995 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1996 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1997 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1999 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
2000 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2001 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2003 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2004 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2008 myActiveDialogBox = 0;
2009 myFilterLibraryDlg = 0;
2013 myEventCallbackCommand = vtkCallbackCommand::New();
2014 myEventCallbackCommand->Delete();
2015 myEventCallbackCommand->SetClientData( this );
2016 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2019 /* load resources for all available meshers */
2020 SMESH::InitAvailableHypotheses();
2023 //=============================================================================
2027 //=============================================================================
2028 SMESHGUI::~SMESHGUI()
2032 //=============================================================================
2036 //=============================================================================
2037 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2039 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2041 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2046 //=============================================================================
2050 //=============================================================================
2051 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2053 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2057 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2058 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2059 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2060 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2061 return autoUpdate && !exceeded;
2064 //=============================================================================
2068 //=============================================================================
2069 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2070 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2072 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2076 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2077 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2078 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2080 SMESH::long_array_var info = theMesh->GetMeshInfo();
2081 long nbOdElems = info[SMDSEntity_0D];
2082 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2083 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2084 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2085 info[SMDSEntity_Polygon];
2086 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2087 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2088 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2089 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2090 info[SMDSEntity_Polyhedra] +
2091 info[SMDSEntity_Hexagonal_Prism];
2092 long nbBalls = info[SMDSEntity_Ball];
2094 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2095 *nbElements = requestedSize;
2097 *entities = SMESH_Actor::eAllEntity;
2100 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2102 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2104 if ( incrementalLimit ) {
2107 if ( nbOdElems > 0 ) {
2108 if ( total + nbOdElems > updateLimit ) {
2109 *entities = *entities & ~SMESH_Actor::e0DElements;
2110 *hidden = *hidden | SMESH_Actor::e0DElements;
2117 if ( nbEdges > 0 ) {
2118 if ( total + nbEdges > updateLimit ) {
2119 *entities = *entities & ~SMESH_Actor::eEdges;
2120 *hidden = *hidden | SMESH_Actor::eEdges;
2127 if ( nbFaces > 0 ) {
2128 if ( total + nbFaces > updateLimit ) {
2129 *entities = *entities & ~SMESH_Actor::eFaces;
2130 *hidden = *hidden | SMESH_Actor::eFaces;
2137 if ( nbVolumes > 0 ) {
2138 if ( total + nbVolumes > updateLimit ) {
2139 *entities = *entities & ~SMESH_Actor::eVolumes;
2140 *hidden = *hidden | SMESH_Actor::eVolumes;
2147 if ( nbBalls > 0 ) {
2148 if ( total + nbBalls > updateLimit ) {
2149 *entities = *entities & ~SMESH_Actor::eBallElem;
2150 *hidden = *hidden | SMESH_Actor::eBallElem;
2158 return autoUpdate && !exceeded;
2161 //=============================================================================
2165 //=============================================================================
2166 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2168 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2171 //=============================================================================
2175 //=============================================================================
2176 SMESHGUI* SMESHGUI::GetSMESHGUI()
2178 SMESHGUI* smeshMod = 0;
2179 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2182 CAM_Module* module = app->module( "Mesh" );
2183 smeshMod = dynamic_cast<SMESHGUI*>( module );
2186 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2188 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2191 _PTR(Study) aStudy = study->studyDS();
2193 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2202 Standard_EXPORT SMESHGUI* GetComponentGUI()
2204 return SMESHGUI::GetSMESHGUI();
2208 //=============================================================================
2212 //=============================================================================
2213 void SMESHGUI::SetState(int aState)
2218 //=============================================================================
2222 //=============================================================================
2223 void SMESHGUI::ResetState()
2228 //=============================================================================
2232 //=============================================================================
2233 void SMESHGUI::EmitSignalDeactivateDialog()
2235 emit SignalDeactivateActiveDialog();
2238 //=============================================================================
2242 //=============================================================================
2243 void SMESHGUI::EmitSignalStudyFrameChanged()
2245 emit SignalStudyFrameChanged();
2248 //=============================================================================
2252 //=============================================================================
2253 void SMESHGUI::EmitSignalCloseAllDialogs()
2255 emit SignalCloseAllDialogs();
2258 //=============================================================================
2262 //=============================================================================
2263 void SMESHGUI::EmitSignalVisibilityChanged()
2265 emit SignalVisibilityChanged();
2268 //=============================================================================
2272 //=============================================================================
2273 QDialog *SMESHGUI::GetActiveDialogBox()
2275 return myActiveDialogBox;
2278 //=============================================================================
2282 //=============================================================================
2283 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2285 myActiveDialogBox = (QDialog *) aDlg;
2289 //=============================================================================
2293 //=============================================================================
2294 SUIT_Desktop* SMESHGUI::desktop()
2296 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2298 return app->desktop();
2303 //=============================================================================
2307 //=============================================================================
2308 SalomeApp_Study* SMESHGUI::activeStudy()
2310 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2312 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2317 //=============================================================================
2321 //=============================================================================
2322 void SMESHGUI::Modified( bool theIsUpdateActions )
2324 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2325 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2326 appStudy->Modified();
2327 if( theIsUpdateActions )
2328 app->updateActions();
2333 //=============================================================================
2337 //=============================================================================
2338 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2340 /* Here the position is on the bottom right corner - 10 */
2341 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2343 SUIT_Desktop *PP = desktop();
2344 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2345 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2349 //=============================================================================
2353 //=============================================================================
2354 static int isStudyLocked(_PTR(Study) theStudy){
2355 return theStudy->GetProperties()->IsLocked();
2358 static bool checkLock(_PTR(Study) theStudy) {
2359 if (isStudyLocked(theStudy)) {
2360 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2361 QObject::tr("WRN_WARNING"),
2362 QObject::tr("WRN_STUDY_LOCKED") );
2368 //=======================================================================
2369 //function : CheckActiveStudyLocked
2371 //=======================================================================
2373 bool SMESHGUI::isActiveStudyLocked()
2375 _PTR(Study) aStudy = activeStudy()->studyDS();
2376 return checkLock( aStudy );
2379 //=============================================================================
2383 //=============================================================================
2384 bool SMESHGUI::OnGUIEvent( int theCommandID )
2386 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2390 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2391 SUIT_ResourceMgr* mgr = resourceMgr();
2395 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2396 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2399 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2400 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2402 //QAction* act = action( theCommandID );
2404 switch (theCommandID) {
2405 case SMESHOp::OpDelete:
2406 if(checkLock(aStudy)) break;
2409 case SMESHOp::OpImportDAT:
2410 case SMESHOp::OpImportUNV:
2411 case SMESHOp::OpImportMED:
2412 case SMESHOp::OpImportSTL:
2414 case SMESHOp::OpImportCGNS:
2416 case SMESHOp::OpImportSAUV:
2417 case SMESHOp::OpImportGMF:
2419 if(checkLock(aStudy)) break;
2420 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2424 case SMESHOp::OpFileInformation:
2426 SALOME_ListIO selected;
2427 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2429 aSel->selectedObjects( selected );
2430 if( selected.Extent() )
2432 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2433 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2434 if ( !aMesh->_is_nil() )
2436 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2442 case SMESHOp::OpExportDAT:
2443 case SMESHOp::OpExportMED:
2444 case SMESHOp::OpExportUNV:
2445 case SMESHOp::OpExportSTL:
2447 case SMESHOp::OpExportCGNS:
2449 case SMESHOp::OpExportSAUV:
2450 case SMESHOp::OpExportGMF:
2451 case SMESHOp::OpPopupExportDAT:
2452 case SMESHOp::OpPopupExportMED:
2453 case SMESHOp::OpPopupExportUNV:
2454 case SMESHOp::OpPopupExportSTL:
2456 case SMESHOp::OpPopupExportCGNS:
2458 case SMESHOp::OpPopupExportSAUV:
2459 case SMESHOp::OpPopupExportGMF:
2461 ::ExportMeshToFile(theCommandID);
2465 case SMESHOp::OpReset: // SCALAR BAR
2467 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2468 SALOME_ListIO selected;
2470 aSel->selectedObjects( selected );
2472 if( selected.Extent() ) {
2473 Handle(SALOME_InteractiveObject) anIO = selected.First();
2474 if( anIO->hasEntry() ) {
2475 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2476 anActor->SetControlMode( SMESH_Actor::eNone );
2477 #ifndef DISABLE_PLOT2DVIEWER
2478 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2485 case SMESHOp::OpScalarBarProperties:
2487 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2490 case SMESHOp::OpShowScalarBar:
2492 // show/hide scalar bar
2493 ::ShowElement(theCommandID);
2496 case SMESHOp::OpSaveDistribution:
2498 // dump control distribution data to the text file
2499 ::SaveDistribution();
2503 case SMESHOp::OpShowDistribution:
2505 // show/hide distribution
2506 ::ShowElement(theCommandID);
2510 #ifndef DISABLE_PLOT2DVIEWER
2511 case SMESHOp::OpPlotDistribution:
2513 // plot distribution
2514 ::PlotDistribution();
2520 case SMESHOp::OpAutoColor:
2524 case SMESHOp::OpDisableAutoColor:
2525 ::DisableAutoColor();
2528 case SMESHOp::OpClipping:
2529 case SMESHOp::OpTransparency:
2530 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2533 case SMESHOp::OpDMWireframe:
2534 case SMESHOp::OpDMShading:
2535 case SMESHOp::OpDMNodes:
2536 case SMESHOp::OpDMShrink:
2537 ::SetDisplayMode(theCommandID, myMarkerMap);
2540 //2D quadratic representation
2541 case SMESHOp::OpRepresentationLines:
2542 case SMESHOp::OpRepresentationArcs:
2543 ::SetDisplayMode(theCommandID, myMarkerMap);
2547 case SMESHOp::OpDE0DElements:
2548 case SMESHOp::OpDEEdges:
2549 case SMESHOp::OpDEFaces:
2550 case SMESHOp::OpDEVolumes:
2551 case SMESHOp::OpDEBalls:
2552 case SMESHOp::OpDEAllEntity:
2553 ::SetDisplayEntity(theCommandID);
2556 // Choose entities to be displayed
2557 case SMESHOp::OpDEChoose:
2559 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2563 case SMESHOp::OpOrientationOnFaces:
2565 LightApp_SelectionMgr* mgr = selectionMgr();
2566 SALOME_ListIO selected; mgr->selectedObjects( selected );
2568 SALOME_ListIteratorOfListIO it(selected);
2569 for( ; it.More(); it.Next()) {
2570 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2571 if(anIObject->hasEntry()) {
2572 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2573 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2580 case SMESHOp::OpUpdate:
2582 if(checkLock(aStudy)) break;
2583 SUIT_OverrideCursor wc;
2585 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2588 SMESH::UpdateView();
2590 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2591 SMESH::OnVisuException();
2593 catch (...) { // PAL16774 (Crash after display of many groups)
2594 SMESH::OnVisuException();
2598 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2599 aSel->selectedObjects( l );
2600 aSel->setSelectedObjects( l );
2604 case SMESHOp::OpHide:
2605 case SMESHOp::OpShow:
2606 case SMESHOp::OpShowOnly:
2608 SMESH::EDisplaing anAction;
2609 switch (theCommandID) {
2610 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2611 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2612 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2615 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2616 SALOME_ListIO sel_objects, to_process;
2618 aSel->selectedObjects( sel_objects );
2620 if( theCommandID==SMESHOp::OpShowOnly )
2622 MESSAGE("anAction = SMESH::eDisplayOnly");
2623 startOperation( myEraseAll );
2626 extractContainers( sel_objects, to_process );
2629 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2633 SALOME_ListIteratorOfListIO It( to_process );
2634 for ( ; It.More(); It.Next()) {
2636 Handle(SALOME_InteractiveObject) IOS = It.Value();
2637 if (IOS->hasEntry()) {
2639 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2640 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2641 break; // PAL16774 (Crash after display of many groups)
2643 if (anAction == SMESH::eDisplayOnly)
2645 MESSAGE("anAction = SMESH::eDisplayOnly");
2646 anAction = SMESH::eDisplay;
2652 // PAL13338 + PAL15161 -->
2653 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2654 MESSAGE("anAction = SMESH::eDisplayOnly");
2655 SMESH::UpdateView();
2656 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2658 // PAL13338 + PAL15161 <--
2660 catch (...) { // PAL16774 (Crash after display of many groups)
2661 SMESH::OnVisuException();
2664 if (anAction == SMESH::eErase) {
2665 MESSAGE("anAction == SMESH::eErase");
2667 aSel->setSelectedObjects( l1 );
2670 aSel->setSelectedObjects( to_process );
2675 case SMESHOp::OpNode:
2677 if(checkLock(aStudy)) break;
2680 EmitSignalDeactivateDialog();
2682 ( new SMESHGUI_NodesDlg( this ) )->show();
2685 SUIT_MessageBox::warning(desktop(),
2686 tr("SMESH_WRN_WARNING"),
2687 tr("SMESH_WRN_VIEWER_VTK"));
2692 case SMESHOp::OpCreateMesh:
2693 case SMESHOp::OpCreateSubMesh:
2694 case SMESHOp::OpEditMeshOrSubMesh:
2695 case SMESHOp::OpCompute:
2696 case SMESHOp::OpPreCompute:
2697 case SMESHOp::OpEvaluate:
2698 case SMESHOp::OpMeshOrder:
2699 startOperation( theCommandID );
2701 case SMESHOp::OpCopyMesh:
2703 if (checkLock(aStudy)) break;
2704 EmitSignalDeactivateDialog();
2705 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2708 case SMESHOp::OpBuildCompoundMesh:
2710 if (checkLock(aStudy)) break;
2711 EmitSignalDeactivateDialog();
2712 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2716 case SMESHOp::OpDiagonalInversion:
2717 case SMESHOp::OpUnionOfTwoTriangle:
2721 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2722 tr( "NOT_A_VTK_VIEWER" ) );
2726 if ( checkLock( aStudy ) )
2729 /*Standard_Boolean aRes;
2730 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2731 if ( aMesh->_is_nil() )
2733 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2734 tr( "SMESH_BAD_SELECTION" ) );
2738 EmitSignalDeactivateDialog();
2739 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2740 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2742 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2745 case SMESHOp::OpOrientation:
2746 case SMESHOp::OpUnionOfTriangles:
2747 case SMESHOp::OpCuttingOfQuadrangles:
2748 case SMESHOp::OpSplitVolumes:
2752 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2753 tr( "NOT_A_VTK_VIEWER" ) );
2757 if ( checkLock( aStudy ) )
2760 EmitSignalDeactivateDialog();
2761 SMESHGUI_MultiEditDlg* aDlg = NULL;
2762 if ( theCommandID == SMESHOp::OpOrientation )
2763 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2764 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2765 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2766 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2767 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2769 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2774 case SMESHOp::OpSmoothing:
2776 if(checkLock(aStudy)) break;
2778 EmitSignalDeactivateDialog();
2779 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2782 SUIT_MessageBox::warning(desktop(),
2783 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2787 case SMESHOp::OpExtrusion:
2789 if (checkLock(aStudy)) break;
2791 EmitSignalDeactivateDialog();
2792 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2794 SUIT_MessageBox::warning(desktop(),
2795 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2799 case SMESHOp::OpExtrusionAlongAPath:
2801 if (checkLock(aStudy)) break;
2803 EmitSignalDeactivateDialog();
2804 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2806 SUIT_MessageBox::warning(desktop(),
2807 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2811 case SMESHOp::OpRevolution:
2813 if(checkLock(aStudy)) break;
2815 EmitSignalDeactivateDialog();
2816 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2819 SUIT_MessageBox::warning(desktop(),
2820 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2824 case SMESHOp::OpPatternMapping:
2826 if ( checkLock( aStudy ) )
2830 EmitSignalDeactivateDialog();
2831 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2834 SUIT_MessageBox::warning(desktop(),
2835 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2839 case SMESHOp::OpConvertMeshToQuadratic:
2840 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2841 case SMESHOp::OpReorientFaces:
2842 case SMESHOp::OpCreateGeometryGroup:
2844 startOperation( theCommandID );
2847 case SMESHOp::OpCreateGroup:
2851 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2852 tr( "NOT_A_VTK_VIEWER" ) );
2856 if(checkLock(aStudy)) break;
2857 EmitSignalDeactivateDialog();
2858 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2860 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2861 SALOME_ListIO selected;
2863 aSel->selectedObjects( selected );
2865 int nbSel = selected.Extent();
2867 // check if mesh is selected
2868 aMesh = SMESH::GetMeshByIO( selected.First() );
2870 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2875 case SMESHOp::OpConstructGroup:
2879 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2880 tr( "NOT_A_VTK_VIEWER" ) );
2884 if(checkLock(aStudy)) break;
2885 EmitSignalDeactivateDialog();
2887 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2888 SALOME_ListIO selected;
2890 aSel->selectedObjects( selected );
2892 int nbSel = selected.Extent();
2894 // check if submesh is selected
2895 Handle(SALOME_InteractiveObject) IObject = selected.First();
2896 if (IObject->hasEntry()) {
2897 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2899 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2900 if (!aSubMesh->_is_nil()) {
2902 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2903 // get submesh elements list by types
2904 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2905 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2906 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2907 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2908 // create group for each type o elements
2909 QString aName = IObject->getName();
2910 QStringList anEntryList;
2911 if (aNodes->length() > 0) {
2912 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2913 aGroup->Add(aNodes.inout());
2914 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2915 anEntryList.append( aSObject->GetID().c_str() );
2917 if (aEdges->length() > 0) {
2918 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2919 aGroup->Add(aEdges.inout());
2920 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2921 anEntryList.append( aSObject->GetID().c_str() );
2923 if (aFaces->length() > 0) {
2924 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2925 aGroup->Add(aFaces.inout());
2926 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2927 anEntryList.append( aSObject->GetID().c_str() );
2929 if (aVolumes->length() > 0) {
2930 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2931 aGroup->Add(aVolumes.inout());
2932 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2933 anEntryList.append( aSObject->GetID().c_str() );
2936 anApp->browseObjects( anEntryList );
2938 catch(const SALOME::SALOME_Exception & S_ex){
2939 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2946 SUIT_MessageBox::warning(desktop(),
2947 tr("SMESH_WRN_WARNING"),
2948 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2953 case SMESHOp::OpEditGroup:
2957 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2958 tr( "NOT_A_VTK_VIEWER" ) );
2962 if(checkLock(aStudy)) break;
2963 EmitSignalDeactivateDialog();
2965 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2966 SALOME_ListIO selected;
2968 aSel->selectedObjects( selected );
2970 SALOME_ListIteratorOfListIO It (selected);
2971 int nbSelectedGroups = 0;
2972 for ( ; It.More(); It.Next() )
2974 SMESH::SMESH_GroupBase_var aGroup =
2975 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2976 if (!aGroup->_is_nil()) {
2978 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2982 if (nbSelectedGroups == 0)
2984 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2990 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2992 if(checkLock(aStudy)) break;
2993 if (myState == 800) {
2994 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2995 if (aDlg) aDlg->onAdd();
3000 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3002 if(checkLock(aStudy)) break;
3003 if (myState == 800) {
3004 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3005 if (aDlg) aDlg->onRemove();
3010 case SMESHOp::OpEditGeomGroupAsGroup:
3014 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3015 tr( "NOT_A_VTK_VIEWER" ) );
3019 if(checkLock(aStudy)) break;
3020 EmitSignalDeactivateDialog();
3022 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3023 SALOME_ListIO selected;
3025 aSel->selectedObjects( selected );
3027 SALOME_ListIteratorOfListIO It (selected);
3028 for ( ; It.More(); It.Next() )
3030 SMESH::SMESH_GroupOnGeom_var aGroup =
3031 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3032 if (!aGroup->_is_nil()) {
3033 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3038 SMESH::SMESH_GroupOnFilter_var aGroup =
3039 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3040 if (!aGroup->_is_nil()) {
3041 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3049 case SMESHOp::OpUnionGroups:
3050 case SMESHOp::OpIntersectGroups:
3051 case SMESHOp::OpCutGroups:
3055 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3056 tr( "NOT_A_VTK_VIEWER" ) );
3060 if ( checkLock( aStudy ) )
3063 EmitSignalDeactivateDialog();
3065 SMESHGUI_GroupOpDlg* aDlg = 0;
3066 if ( theCommandID == SMESHOp::OpUnionGroups )
3067 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3068 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3069 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3071 aDlg = new SMESHGUI_CutGroupsDlg( this );
3078 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3080 if ( checkLock( aStudy ) )
3083 EmitSignalDeactivateDialog();
3084 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3090 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3094 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3095 tr( "NOT_A_VTK_VIEWER" ) );
3099 if ( checkLock( aStudy ) )
3102 EmitSignalDeactivateDialog();
3104 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3108 case SMESHOp::OpMeshInformation:
3109 case SMESHOp::OpWhatIs:
3111 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3112 EmitSignalDeactivateDialog();
3113 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3114 SALOME_ListIO selected;
3116 aSel->selectedObjects( selected );
3118 if ( selected.Extent() > 1 ) { // a dlg for each IO
3119 SALOME_ListIteratorOfListIO It( selected );
3120 for ( ; It.More(); It.Next() ) {
3121 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3122 dlg->showInfo( It.Value() );
3127 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3133 case SMESHOp::OpFindElementByPoint:
3135 startOperation( theCommandID );
3139 case SMESHOp::OpEditHypothesis:
3141 if(checkLock(aStudy)) break;
3143 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3144 SALOME_ListIO selected;
3146 aSel->selectedObjects( selected );
3148 int nbSel = selected.Extent();
3151 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3152 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3154 if ( !aHypothesis->_is_nil() )
3156 SMESHGUI_GenericHypothesisCreator* aCreator =
3157 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3160 // set geometry of mesh and sub-mesh to aCreator
3161 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3162 if ( selected.Extent() == 1 )
3164 QString subGeomID, meshGeomID;
3165 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3166 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3168 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3169 aCreator->setShapeEntry( subGeomID );
3170 aCreator->setMainShapeEntry( meshGeomID );
3174 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3184 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3186 if(checkLock(aStudy)) break;
3187 SUIT_OverrideCursor wc;
3189 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3190 SALOME_ListIO selected;
3192 aSel->selectedObjects( selected, QString::null, false );
3194 SALOME_ListIteratorOfListIO It(selected);
3195 for (int i = 0; It.More(); It.Next(), i++) {
3196 Handle(SALOME_InteractiveObject) IObject = It.Value();
3197 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3200 aSel->setSelectedObjects( l1 );
3205 case SMESHOp::OpElem0D:
3206 case SMESHOp::OpBall:
3207 case SMESHOp::OpEdge:
3208 case SMESHOp::OpTriangle:
3209 case SMESHOp::OpQuadrangle:
3210 case SMESHOp::OpPolygon:
3211 case SMESHOp::OpTetrahedron:
3212 case SMESHOp::OpHexahedron:
3213 case SMESHOp::OpPentahedron:
3214 case SMESHOp::OpPyramid:
3215 case SMESHOp::OpHexagonalPrism:
3217 if(checkLock(aStudy)) break;
3219 EmitSignalDeactivateDialog();
3220 SMDSAbs_EntityType type = SMDSEntity_Edge;
3221 switch (theCommandID) {
3222 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3223 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3224 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3225 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3226 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3227 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3228 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3229 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3230 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3231 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3234 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3237 SUIT_MessageBox::warning(desktop(),
3238 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3242 case SMESHOp::OpPolyhedron:
3244 if(checkLock(aStudy)) break;
3246 EmitSignalDeactivateDialog();
3247 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3250 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3251 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3255 case SMESHOp::OpQuadraticEdge:
3256 case SMESHOp::OpQuadraticTriangle:
3257 case SMESHOp::OpBiQuadraticTriangle:
3258 case SMESHOp::OpQuadraticQuadrangle:
3259 case SMESHOp::OpBiQuadraticQuadrangle:
3260 case SMESHOp::OpQuadraticTetrahedron:
3261 case SMESHOp::OpQuadraticPyramid:
3262 case SMESHOp::OpQuadraticPentahedron:
3263 case SMESHOp::OpQuadraticHexahedron:
3264 case SMESHOp::OpTriQuadraticHexahedron:
3266 if(checkLock(aStudy)) break;
3268 EmitSignalDeactivateDialog();
3269 SMDSAbs_EntityType type = SMDSEntity_Last;
3271 switch (theCommandID) {
3272 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3273 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3274 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3275 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3276 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3277 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3278 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3279 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3280 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3281 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3284 if ( type != SMDSEntity_Last )
3285 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3288 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3289 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3293 case SMESHOp::OpRemoveNodes:
3295 if(checkLock(aStudy)) break;
3297 EmitSignalDeactivateDialog();
3298 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3301 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3302 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3306 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3308 if(checkLock(aStudy)) break;
3310 EmitSignalDeactivateDialog();
3311 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3315 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3316 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3320 case SMESHOp::OpClearMesh: {
3322 if(checkLock(aStudy)) break;
3324 SALOME_ListIO selected;
3325 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3326 aSel->selectedObjects( selected );
3328 SUIT_OverrideCursor wc;
3329 SALOME_ListIteratorOfListIO It (selected);
3330 for ( ; It.More(); It.Next() )
3332 Handle(SALOME_InteractiveObject) IOS = It.Value();
3333 SMESH::SMESH_Mesh_var aMesh =
3334 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3335 if ( aMesh->_is_nil()) continue;
3337 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3339 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3340 SMESH::ModifiedMesh( aMeshSObj, false, true);
3341 // hide groups and submeshes
3342 _PTR(ChildIterator) anIter =
3343 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3344 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3346 _PTR(SObject) so = anIter->Value();
3347 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3350 catch (const SALOME::SALOME_Exception& S_ex){
3352 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3356 SMESH::UpdateView();
3360 case SMESHOp::OpRemoveOrphanNodes:
3362 if(checkLock(aStudy)) break;
3363 SALOME_ListIO selected;
3364 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3365 aSel->selectedObjects( selected );
3366 if ( selected.Extent() == 1 ) {
3367 Handle(SALOME_InteractiveObject) anIO = selected.First();
3368 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3369 if ( !aMesh->_is_nil() ) {
3370 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3371 tr( "SMESH_WARNING" ),
3372 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3373 SUIT_MessageBox::Yes |
3374 SUIT_MessageBox::No,
3375 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3378 SUIT_OverrideCursor wc;
3379 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3380 int removed = aMeshEditor->RemoveOrphanNodes();
3381 SUIT_MessageBox::information(SMESHGUI::desktop(),
3382 tr("SMESH_INFORMATION"),
3383 tr("NB_NODES_REMOVED").arg(removed));
3384 if ( removed > 0 ) {
3385 SMESH::UpdateView();
3386 SMESHGUI::Modified();
3389 catch (const SALOME::SALOME_Exception& S_ex) {
3390 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3399 case SMESHOp::OpRenumberingNodes:
3401 if(checkLock(aStudy)) break;
3403 EmitSignalDeactivateDialog();
3404 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3408 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3409 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3413 case SMESHOp::OpRenumberingElements:
3415 if(checkLock(aStudy)) break;
3417 EmitSignalDeactivateDialog();
3418 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3422 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3423 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3427 case SMESHOp::OpTranslation:
3429 if(checkLock(aStudy)) break;
3431 EmitSignalDeactivateDialog();
3432 ( new SMESHGUI_TranslationDlg( this ) )->show();
3435 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3436 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3440 case SMESHOp::OpRotation:
3442 if(checkLock(aStudy)) break;
3444 EmitSignalDeactivateDialog();
3445 ( new SMESHGUI_RotationDlg( this ) )->show();
3448 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3449 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3453 case SMESHOp::OpSymmetry:
3455 if(checkLock(aStudy)) break;
3457 EmitSignalDeactivateDialog();
3458 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3461 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3462 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3466 case SMESHOp::OpScale:
3468 if(checkLock(aStudy)) break;
3470 EmitSignalDeactivateDialog();
3471 ( new SMESHGUI_ScaleDlg( this ) )->show();
3474 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3475 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3480 case SMESHOp::OpSewing:
3482 if(checkLock(aStudy)) break;
3484 EmitSignalDeactivateDialog();
3485 ( new SMESHGUI_SewingDlg( this ) )->show();
3488 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3489 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3493 case SMESHOp::OpMergeNodes:
3495 if(checkLock(aStudy)) break;
3497 EmitSignalDeactivateDialog();
3498 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3501 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3502 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3506 case SMESHOp::OpMergeElements:
3508 if (checkLock(aStudy)) break;
3510 EmitSignalDeactivateDialog();
3511 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3513 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3514 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3519 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3520 startOperation( SMESHOp::OpMoveNode );
3523 case SMESHOp::OpDuplicateNodes:
3525 if(checkLock(aStudy)) break;
3527 EmitSignalDeactivateDialog();
3528 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3531 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3532 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3537 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3538 startOperation( SMESHOp::OpElem0DOnElemNodes );
3541 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3543 static QList<int> aTypes;
3544 if ( aTypes.isEmpty() )
3546 aTypes.append( SMESH::NODE );
3547 aTypes.append( SMESH::EDGE );
3548 aTypes.append( SMESH::FACE );
3549 aTypes.append( SMESH::VOLUME );
3551 if (!myFilterLibraryDlg)
3552 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3553 else if (myFilterLibraryDlg->isHidden())
3554 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3555 myFilterLibraryDlg->raise();
3559 case SMESHOp::OpFreeNode:
3560 case SMESHOp::OpEqualNode:
3561 case SMESHOp::OpFreeEdge:
3562 case SMESHOp::OpFreeBorder:
3563 case SMESHOp::OpLength:
3564 case SMESHOp::OpConnection:
3565 case SMESHOp::OpEqualEdge:
3566 case SMESHOp::OpFreeFace:
3567 case SMESHOp::OpBareBorderFace:
3568 case SMESHOp::OpOverConstrainedFace:
3569 case SMESHOp::OpLength2D:
3570 case SMESHOp::OpConnection2D:
3571 case SMESHOp::OpArea:
3572 case SMESHOp::OpTaper:
3573 case SMESHOp::OpAspectRatio:
3574 case SMESHOp::OpMinimumAngle:
3575 case SMESHOp::OpWarpingAngle:
3576 case SMESHOp::OpSkew:
3577 case SMESHOp::OpMaxElementLength2D:
3578 case SMESHOp::OpEqualFace:
3579 case SMESHOp::OpAspectRatio3D:
3580 case SMESHOp::OpVolume:
3581 case SMESHOp::OpMaxElementLength3D:
3582 case SMESHOp::OpBareBorderVolume:
3583 case SMESHOp::OpOverConstrainedVolume:
3584 case SMESHOp::OpEqualVolume:
3587 LightApp_SelectionMgr* mgr = selectionMgr();
3588 SALOME_ListIO selected; mgr->selectedObjects( selected );
3590 if( !selected.IsEmpty() ) {
3591 SUIT_OverrideCursor wc;
3592 ::Control( theCommandID );
3595 SUIT_MessageBox::warning(desktop(),
3596 tr( "SMESH_WRN_WARNING" ),
3597 tr( "SMESH_BAD_SELECTION" ) );
3601 SUIT_MessageBox::warning(desktop(),
3602 tr( "SMESH_WRN_WARNING" ),
3603 tr( "NOT_A_VTK_VIEWER" ) );
3606 case SMESHOp::OpOverallMeshQuality:
3607 OverallMeshQuality();
3609 case SMESHOp::OpNumberingNodes:
3611 SUIT_OverrideCursor wc;
3612 LightApp_SelectionMgr* mgr = selectionMgr();
3613 SALOME_ListIO selected; mgr->selectedObjects( selected );
3615 SALOME_ListIteratorOfListIO it(selected);
3616 for( ; it.More(); it.Next()) {
3617 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3618 if(anIObject->hasEntry()) {
3619 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3620 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3626 case SMESHOp::OpNumberingElements:
3628 SUIT_OverrideCursor wc;
3629 LightApp_SelectionMgr* mgr = selectionMgr();
3630 SALOME_ListIO selected; mgr->selectedObjects( selected );
3632 SALOME_ListIteratorOfListIO it(selected);
3633 for( ; it.More(); it.Next()) {
3634 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3635 if(anIObject->hasEntry())
3636 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3637 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3642 case SMESHOp::OpPropertiesLength:
3643 case SMESHOp::OpPropertiesArea:
3644 case SMESHOp::OpPropertiesVolume:
3645 case SMESHOp::OpMinimumDistance:
3646 case SMESHOp::OpBoundingBox:
3648 int page = SMESHGUI_MeasureDlg::MinDistance;
3649 if ( theCommandID == SMESHOp::OpBoundingBox )
3650 page = SMESHGUI_MeasureDlg::BoundingBox;
3651 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3652 page = SMESHGUI_MeasureDlg::Length;
3653 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3654 page = SMESHGUI_MeasureDlg::Area;
3655 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3656 page = SMESHGUI_MeasureDlg::Volume;
3658 EmitSignalDeactivateDialog();
3659 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3663 case SMESHOp::OpSortChild:
3669 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3670 //updateObjBrowser();
3674 //=============================================================================
3678 //=============================================================================
3679 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3684 //=============================================================================
3688 //=============================================================================
3689 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3694 //=============================================================================
3698 //=============================================================================
3699 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3704 //=============================================================================
3705 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3706 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3708 //=============================================================================
3709 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3710 SUIT_ViewWindow* wnd )
3712 if(theIO->hasEntry()){
3713 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3714 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3718 //=======================================================================
3719 // function : createSMESHAction
3721 //=======================================================================
3722 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3723 const int key, const bool toggle, const QString& shortcutAction )
3726 QWidget* parent = application()->desktop();
3727 SUIT_ResourceMgr* resMgr = resourceMgr();
3729 if ( !icon_id.isEmpty() )
3730 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3732 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3733 if ( !pix.isNull() )
3734 icon = QIcon( pix );
3736 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3737 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3738 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3740 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3741 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3744 //=======================================================================
3745 // function : createPopupItem
3747 //=======================================================================
3748 void SMESHGUI::createPopupItem( const int id,
3749 const QString& clients,
3750 const QString& types,
3751 const QString& theRule,
3754 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3755 popupMgr()->insert( action( id ), pId, 0 );
3757 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3758 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3759 QString rule = "(%1) and (%2) and (%3)";
3760 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3761 if( clients.isEmpty() )
3762 rule = rule.arg( QString( "true" ) );
3764 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3765 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3768 bool cont = myRules.contains( id );
3770 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3772 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3773 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3776 //=======================================================================
3777 // function : initialize
3779 //=======================================================================
3780 void SMESHGUI::initialize( CAM_Application* app )
3782 SalomeApp_Module::initialize( app );
3784 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3786 /* Automatic Update flag */
3787 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3789 // ----- create actions --------------
3791 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3792 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3793 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3794 //createSMESHAction( 114, "NUM" );
3795 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3797 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3799 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3800 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3801 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3802 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3803 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3804 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3806 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3808 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3809 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3810 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3811 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3812 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3813 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3815 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3817 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3818 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3819 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3820 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3821 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3822 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3823 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3824 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3825 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3826 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3827 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3828 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3829 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3830 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3831 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3832 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3833 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3834 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3835 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3836 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3837 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3838 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3839 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3840 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3841 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3842 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3843 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3844 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3845 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3846 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3848 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3849 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3850 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3851 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3852 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3853 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3854 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3855 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3856 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3857 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3858 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3859 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3860 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3861 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3862 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3863 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3864 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3865 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3866 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3867 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3868 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3869 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3870 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3871 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3872 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3873 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3874 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3876 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3877 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3878 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3879 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3880 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3881 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3882 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3883 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3884 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3885 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3886 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3887 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3888 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3889 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3890 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3891 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3892 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3893 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3894 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3895 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3896 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3897 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3898 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3899 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3901 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3902 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3903 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3904 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3906 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3907 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3909 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3910 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3911 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3912 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3913 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3914 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3915 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3916 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3917 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3918 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3919 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3920 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3921 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3922 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3923 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3924 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3925 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3926 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3927 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3928 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3929 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3930 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3931 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3933 createSMESHAction( SMESHOp::OpReset, "RESET" );
3934 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3935 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3936 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3937 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3938 #ifndef DISABLE_PLOT2DVIEWER
3939 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3941 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3942 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3943 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3944 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3945 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3946 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3947 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3948 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3949 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3950 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3951 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3952 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3953 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3955 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3956 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3958 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3959 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3960 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3961 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3962 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3963 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3964 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3965 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3966 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3968 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3969 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3970 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3971 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3972 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3974 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3975 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3976 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3978 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3980 QList<int> aCtrlActions;
3981 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3982 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3983 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3984 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3985 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3986 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3987 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3988 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3989 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3990 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3991 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3992 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3993 aCtrlGroup->setExclusive( true );
3994 for( int i = 0; i < aCtrlActions.size(); i++ )
3995 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3997 // ----- create menu --------------
3998 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3999 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4000 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4001 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4002 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4003 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4004 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4005 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4007 createMenu( separator(), fileId );
4009 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4010 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4011 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
4012 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
4013 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
4014 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
4015 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4016 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4017 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4018 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4019 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4021 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4022 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4023 createMenu( SMESHOp::OpImportMED, importId, -1 );
4024 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4026 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4028 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4029 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4030 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4031 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4032 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4033 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4035 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4037 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4038 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4039 createMenu( separator(), fileId, 10 );
4041 createMenu( SMESHOp::OpDelete, editId, -1 );
4043 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4045 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4046 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4047 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4048 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4049 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4050 createMenu( separator(), meshId, -1 );
4051 createMenu( SMESHOp::OpCompute, meshId, -1 );
4052 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4053 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4054 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4055 createMenu( separator(), meshId, -1 );
4056 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4057 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4058 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4059 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4060 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4061 createMenu( separator(), meshId, -1 );
4062 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4063 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4064 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4065 createMenu( separator(), meshId, -1 );
4066 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4067 createMenu( separator(), meshId, -1 );
4068 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4069 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4070 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4071 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4072 createMenu( separator(), meshId, -1 );
4074 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4075 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4076 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4077 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4078 createMenu( SMESHOp::OpLength, edgeId, -1 );
4079 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4080 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4081 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4082 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4083 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4084 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4085 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4086 createMenu( SMESHOp::OpArea, faceId, -1 );
4087 createMenu( SMESHOp::OpTaper, faceId, -1 );
4088 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4089 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4090 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4091 createMenu( SMESHOp::OpSkew, faceId, -1 );
4092 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4093 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4094 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4095 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4096 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4097 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4098 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4099 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4100 createMenu( separator(), ctrlId, -1 );
4101 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4102 createMenu( separator(), ctrlId, -1 );
4103 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4105 createMenu( SMESHOp::OpNode, addId, -1 );
4106 createMenu( SMESHOp::OpElem0D, addId, -1 );
4107 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4108 createMenu( SMESHOp::OpBall, addId, -1 );
4109 createMenu( SMESHOp::OpEdge, addId, -1 );
4110 createMenu( SMESHOp::OpTriangle, addId, -1 );
4111 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4112 createMenu( SMESHOp::OpPolygon, addId, -1 );
4113 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4114 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4115 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4116 createMenu( SMESHOp::OpPyramid, addId, -1 );
4117 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4118 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4119 createMenu( separator(), addId, -1 );
4120 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4121 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4122 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4123 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4124 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4125 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4126 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4127 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4128 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4129 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4131 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4132 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4133 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4134 createMenu( separator(), removeId, -1 );
4135 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4136 createMenu( separator(), removeId, -1 );
4137 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4139 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4140 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4142 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4143 createMenu( SMESHOp::OpRotation, transfId, -1 );
4144 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4145 createMenu( SMESHOp::OpScale, transfId, -1 );
4146 createMenu( SMESHOp::OpSewing, transfId, -1 );
4147 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4148 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4149 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4151 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4152 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4153 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4154 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4155 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4156 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4157 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4158 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4159 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4160 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4161 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4162 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4163 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4164 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4165 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4167 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4168 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4169 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4170 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4171 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4172 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4174 // ----- create toolbars --------------
4175 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4176 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4177 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4178 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4179 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4180 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4181 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4182 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4183 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4184 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4185 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4186 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4187 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4188 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4189 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4191 createTool( SMESHOp::OpCreateMesh, meshTb );
4192 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4193 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4194 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4195 createTool( SMESHOp::OpCopyMesh, meshTb );
4196 createTool( separator(), meshTb );
4197 createTool( SMESHOp::OpCompute, meshTb );
4198 createTool( SMESHOp::OpPreCompute, meshTb );
4199 createTool( SMESHOp::OpEvaluate, meshTb );
4200 createTool( SMESHOp::OpMeshOrder, meshTb );
4202 createTool( SMESHOp::OpCreateGroup, groupTb );
4203 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4204 createTool( SMESHOp::OpConstructGroup, groupTb );
4205 createTool( SMESHOp::OpEditGroup, groupTb );
4207 createTool( SMESHOp::OpMeshInformation, info );
4208 //createTool( SMESHOp::OpStdInfo, meshTb );
4209 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4210 createTool( SMESHOp::OpFindElementByPoint, info );
4212 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4213 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4215 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4216 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4217 createTool( SMESHOp::OpLength, ctrl1dTb );
4218 createTool( SMESHOp::OpConnection, ctrl1dTb );
4219 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4221 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4222 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4223 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4224 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4225 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4226 createTool( SMESHOp::OpArea, ctrl2dTb );
4227 createTool( SMESHOp::OpTaper, ctrl2dTb );
4228 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4229 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4230 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4231 createTool( SMESHOp::OpSkew, ctrl2dTb );
4232 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4233 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4235 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4236 createTool( SMESHOp::OpVolume, ctrl3dTb );
4237 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4238 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4239 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4240 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4242 createTool( SMESHOp::OpNode, addElemTb );
4243 createTool( SMESHOp::OpElem0D, addElemTb );
4244 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4245 createTool( SMESHOp::OpBall, addElemTb );
4246 createTool( SMESHOp::OpEdge, addElemTb );
4247 createTool( SMESHOp::OpTriangle, addElemTb );
4248 createTool( SMESHOp::OpQuadrangle, addElemTb );
4249 createTool( SMESHOp::OpPolygon, addElemTb );
4250 createTool( SMESHOp::OpTetrahedron, addElemTb );
4251 createTool( SMESHOp::OpHexahedron, addElemTb );
4252 createTool( SMESHOp::OpPentahedron, addElemTb );
4253 createTool( SMESHOp::OpPyramid, addElemTb );
4254 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4255 createTool( SMESHOp::OpPolyhedron, addElemTb );
4257 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4258 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4259 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4260 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4261 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4262 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4263 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4264 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4265 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4266 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4268 createTool( SMESHOp::OpRemoveNodes, remTb );
4269 createTool( SMESHOp::OpRemoveElements, remTb );
4270 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4271 createTool( SMESHOp::OpClearMesh, remTb );
4273 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4274 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4276 createTool( SMESHOp::OpTranslation, transformTb );
4277 createTool( SMESHOp::OpRotation, transformTb );
4278 createTool( SMESHOp::OpSymmetry, transformTb );
4279 createTool( SMESHOp::OpScale, transformTb );
4280 createTool( SMESHOp::OpSewing, transformTb );
4281 createTool( SMESHOp::OpMergeNodes, transformTb );
4282 createTool( SMESHOp::OpMergeElements, transformTb );
4283 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4285 createTool( SMESHOp::OpMoveNode, modifyTb );
4286 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4287 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4288 createTool( SMESHOp::OpOrientation, modifyTb );
4289 createTool( SMESHOp::OpReorientFaces, modifyTb );
4290 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4291 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4292 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4293 createTool( SMESHOp::OpSmoothing, modifyTb );
4294 createTool( SMESHOp::OpExtrusion, modifyTb );
4295 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4296 createTool( SMESHOp::OpRevolution, modifyTb );
4297 createTool( SMESHOp::OpPatternMapping, modifyTb );
4298 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4299 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4301 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4303 createTool( SMESHOp::OpUpdate, dispModeTb );
4305 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4306 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4309 QString OB = "'ObjectBrowser'",
4310 View = "'" + SVTK_Viewer::Type() + "'",
4312 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4313 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4314 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4315 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4316 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4317 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4318 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4319 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4320 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4321 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4322 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4324 mesh_part = mesh + " " + subMesh + " " + group,
4325 mesh_group = mesh + " " + group,
4326 hyp_alg = hypo + " " + algo;
4328 // popup for object browser
4330 isInvisible("not( isVisible )"),
4331 isEmpty("numberOfNodes = 0"),
4332 isNotEmpty("numberOfNodes <> 0"),
4334 // has nodes, edges, etc in VISIBLE! actor
4335 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4336 hasElems("(count( elemTypes ) > 0)"),
4337 hasDifferentElems("(count( elemTypes ) > 1)"),
4338 hasBalls("({'BallElem'} in elemTypes)"),
4339 hasElems0d("({'Elem0d'} in elemTypes)"),
4340 hasEdges("({'Edge'} in elemTypes)"),
4341 hasFaces("({'Face'} in elemTypes)"),
4342 hasVolumes("({'Volume'} in elemTypes)");
4344 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4345 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4346 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4347 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4348 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4349 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4351 popupMgr()->insert( separator(), -1, 0 );
4352 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4353 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4354 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4355 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4356 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4357 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4358 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4359 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4360 popupMgr()->insert( separator(), -1, 0 );
4361 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4362 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4363 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4364 popupMgr()->insert( separator(), -1, 0 );
4365 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4366 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4367 popupMgr()->insert( separator(), -1, 0 );
4368 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4369 popupMgr()->insert( separator(), -1, 0 );
4370 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4371 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4373 popupMgr()->insert( separator(), -1, 0 );
4375 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4376 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4377 QString only_one_2D = only_one_non_empty + " && dim>1";
4379 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4380 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4381 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4382 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4384 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4386 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, multiple_non_empty, anId );
4387 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, multiple_non_empty, anId );
4388 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, multiple_non_empty, anId );
4389 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4390 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4391 popupMgr()->insert( separator(), -1, 0 );
4394 createPopupItem( SMESHOp::OpEditGroup, View, group );
4395 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4396 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4398 popupMgr()->insert( separator(), -1, 0 );
4399 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4400 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4401 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4402 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4403 popupMgr()->insert( separator(), -1, 0 );
4405 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4406 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4407 popupMgr()->insert( separator(), -1, 0 );
4409 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4410 QString aType = QString( "%1type in {%2}" ).arg( lc );
4411 aType = aType.arg( mesh_part );
4412 QString aMeshInVTK = aClient + "&&" + aType;
4414 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4415 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4416 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4418 //-------------------------------------------------
4420 //-------------------------------------------------
4421 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4423 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4424 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4425 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4427 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4428 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4429 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4431 popupMgr()->insert( separator(), -1, -1 );
4433 //-------------------------------------------------
4435 //-------------------------------------------------
4436 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4438 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4439 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4440 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4442 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4443 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4444 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4446 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4447 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4448 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4450 popupMgr()->insert( separator(), anId, -1 );
4452 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4453 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4454 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4456 //-------------------------------------------------
4458 //-------------------------------------------------
4459 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4461 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4463 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4464 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4465 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4467 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4468 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4469 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4471 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4472 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4473 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4475 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4476 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4477 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4479 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4480 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4481 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4483 popupMgr()->insert( separator(), anId, -1 );
4485 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4486 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4488 popupMgr()->insert( separator(), anId, -1 );
4490 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4491 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4494 //-------------------------------------------------
4495 // Representation of the 2D Quadratic elements
4496 //-------------------------------------------------
4497 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4498 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4499 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4500 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4502 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4503 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4504 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4506 //-------------------------------------------------
4507 // Orientation of faces
4508 //-------------------------------------------------
4509 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4510 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4511 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4513 //-------------------------------------------------
4515 //-------------------------------------------------
4516 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4517 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4519 //-------------------------------------------------
4521 //-------------------------------------------------
4522 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4523 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4525 //-------------------------------------------------
4527 //-------------------------------------------------
4529 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4530 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4531 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4532 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4534 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4536 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4537 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4539 popupMgr()->insert( separator(), anId, -1 );
4541 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4543 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4544 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4545 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4547 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4548 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4549 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4551 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4553 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4554 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4555 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4557 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4558 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4559 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4561 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4562 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4563 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4565 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4566 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4567 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4568 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4569 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4570 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4572 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4574 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4575 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4576 QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4579 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4581 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4583 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4584 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4585 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4587 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4588 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4589 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4591 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4592 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4593 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4595 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4597 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4599 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4600 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4601 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4603 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4611 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4613 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4615 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4616 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4617 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4619 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4620 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4621 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4622 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4624 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4626 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4628 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4630 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4632 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4633 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4634 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4636 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4637 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4638 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4640 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4641 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4642 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4644 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4646 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4648 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4650 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4652 popupMgr()->insert( separator(), anId, -1 );
4654 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4655 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4656 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4657 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4660 popupMgr()->insert( separator(), anId, -1 );
4662 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4664 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4665 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4667 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4671 #ifndef DISABLE_PLOT2DVIEWER
4672 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4673 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4676 //-------------------------------------------------
4678 //-------------------------------------------------
4679 popupMgr()->insert( separator(), -1, -1 );
4680 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4681 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4682 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4685 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4686 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4688 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4689 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4691 popupMgr()->insert( separator(), -1, -1 );
4693 //-------------------------------------------------
4695 //-------------------------------------------------
4696 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4697 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4699 popupMgr()->insert( separator(), -1, -1 );
4701 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4703 popupMgr()->insert( separator(), -1, -1 );
4705 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4706 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4708 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4709 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4712 //================================================================================
4714 * \brief Return true if SMESH or GEOM objects are selected.
4715 * Is called form LightApp_Module::activateModule() which clear selection if
4716 * not isSelectionCompatible()
4718 //================================================================================
4720 bool SMESHGUI::isSelectionCompatible()
4722 bool isCompatible = true;
4723 SALOME_ListIO selected;
4724 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4725 Sel->selectedObjects( selected );
4727 SALOME_ListIteratorOfListIO It( selected );
4728 for ( ; isCompatible && It.More(); It.Next())
4730 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4731 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4733 return isCompatible;
4737 bool SMESHGUI::reusableOperation( const int id )
4739 // compute, evaluate and precompute are not reusable operations
4740 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4743 bool SMESHGUI::activateModule( SUIT_Study* study )
4745 bool res = SalomeApp_Module::activateModule( study );
4747 setMenuShown( true );
4748 setToolShown( true );
4750 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4751 PyGILState_STATE gstate = PyGILState_Ensure();
4752 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4753 if ( !pluginsmanager ) {
4757 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4761 PyGILState_Release(gstate);
4762 // end of SMESH plugins loading
4764 // Reset actions accelerator keys
4765 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4767 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4768 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4769 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4770 if ( _PTR(Study) aStudy = s->studyDS()) {
4771 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4772 updateObjBrowser(); // objects can be removed
4775 // get all view currently opened in the study and connect their signals to
4776 // the corresponding slots of the class.
4777 SUIT_Desktop* aDesk = study->application()->desktop();
4779 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4780 SUIT_ViewWindow* wnd;
4781 foreach ( wnd, wndList )
4788 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4790 setMenuShown( false );
4791 setToolShown( false );
4793 EmitSignalCloseAllDialogs();
4795 // Unset actions accelerator keys
4796 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4798 return SalomeApp_Module::deactivateModule( study );
4801 void SMESHGUI::studyClosed( SUIT_Study* s )
4805 SMESH::RemoveVisuData( s->id() );
4806 SalomeApp_Module::studyClosed( s );
4809 void SMESHGUI::OnGUIEvent()
4811 const QObject* obj = sender();
4812 if ( !obj || !obj->inherits( "QAction" ) )
4814 int id = actionId((QAction*)obj);
4819 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4821 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4822 if ( CORBA::is_nil( myComponentSMESH ) )
4824 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4826 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4827 return aGUI.myComponentSMESH;
4830 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4831 return myComponentSMESH;
4834 QString SMESHGUI::engineIOR() const
4836 CORBA::ORB_var anORB = getApp()->orb();
4837 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4838 return QString( anIOR.in() );
4841 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4843 SalomeApp_Module::contextMenuPopup( client, menu, title );
4845 selectionMgr()->selectedObjects( lst );
4846 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4847 Handle(SALOME_InteractiveObject) io = lst.First();
4848 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4849 _PTR(Study) study = appStudy->studyDS();
4850 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4852 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4853 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4854 aName.remove( (aName.length() - 1), 1 );
4860 LightApp_Selection* SMESHGUI::createSelection() const
4862 return new SMESHGUI_Selection();
4865 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4867 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4868 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4869 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4872 void SMESHGUI::viewManagers( QStringList& list ) const
4874 list.append( SVTK_Viewer::Type() );
4877 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4879 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4880 SMESH::UpdateSelectionProp( this );
4882 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4883 for(int i = 0; i < aViews.count() ; i++){
4884 SUIT_ViewWindow *sf = aViews[i];
4890 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4892 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4893 myClippingPlaneInfoMap.erase( theViewManager );
4896 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4898 theActor->AddObserver( SMESH::DeleteActorEvent,
4899 myEventCallbackCommand.GetPointer(),
4903 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4904 unsigned long theEvent,
4905 void* theClientData,
4908 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4909 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4910 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4911 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4912 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4913 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4914 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4915 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4916 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4917 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4918 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4919 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4920 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4921 if( anActor == *anIter3 ) {
4922 anActorList.erase( anIter3 );
4933 void SMESHGUI::createPreferences()
4935 // General tab ------------------------------------------------------------------------
4936 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4938 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4939 setPreferenceProperty( autoUpdate, "columns", 2 );
4940 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4941 setPreferenceProperty( lim, "min", 0 );
4942 setPreferenceProperty( lim, "max", 100000000 );
4943 setPreferenceProperty( lim, "step", 1000 );
4944 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4945 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4947 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4948 setPreferenceProperty( qaGroup, "columns", 2 );
4949 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4950 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4951 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4952 setPreferenceProperty( prec, "min", 0 );
4953 setPreferenceProperty( prec, "max", 100 );
4954 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4955 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4956 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4957 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4958 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4960 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4961 setPreferenceProperty( dispgroup, "columns", 2 );
4962 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4964 modes.append( tr("MEN_WIRE") );
4965 modes.append( tr("MEN_SHADE") );
4966 modes.append( tr("MEN_NODES") );
4967 modes.append( tr("MEN_SHRINK") );
4968 QList<QVariant> indices;
4969 indices.append( 0 );
4970 indices.append( 1 );
4971 indices.append( 2 );
4972 indices.append( 3 );
4973 setPreferenceProperty( dispmode, "strings", modes );
4974 setPreferenceProperty( dispmode, "indexes", indices );
4976 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4977 setPreferenceProperty( arcgroup, "columns", 2 );
4978 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4979 QStringList quadraticModes;
4980 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4981 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4983 indices.append( 0 );
4984 indices.append( 1 );
4985 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4986 setPreferenceProperty( quadraticmode, "indexes", indices );
4988 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4989 "SMESH", "max_angle" );
4990 setPreferenceProperty( maxAngle, "min", 1 );
4991 setPreferenceProperty( maxAngle, "max", 90 );
4995 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4996 setPreferenceProperty( exportgroup, "columns", 2 );
4997 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4998 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5000 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5001 setPreferenceProperty( computeGroup, "columns", 2 );
5002 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5004 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5005 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5006 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5008 indices.append( 0 );
5009 indices.append( 1 );
5010 indices.append( 2 );
5011 setPreferenceProperty( notifyMode, "strings", modes );
5012 setPreferenceProperty( notifyMode, "indexes", indices );
5014 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5015 setPreferenceProperty( infoGroup, "columns", 2 );
5016 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5018 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5019 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5021 indices.append( 0 );
5022 indices.append( 1 );
5023 setPreferenceProperty( elemInfo, "strings", modes );
5024 setPreferenceProperty( elemInfo, "indexes", indices );
5025 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5026 setPreferenceProperty( nodesLim, "min", 0 );
5027 setPreferenceProperty( nodesLim, "max", 10000000 );
5028 setPreferenceProperty( nodesLim, "step", 10000 );
5029 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5030 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5031 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5032 setPreferenceProperty( ctrlLim, "min", 0 );
5033 setPreferenceProperty( ctrlLim, "max", 10000000 );
5034 setPreferenceProperty( ctrlLim, "step", 1000 );
5035 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5036 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5037 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5038 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5039 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5041 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5042 setPreferenceProperty( segGroup, "columns", 2 );
5043 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5044 "SMESH", "segmentation" );
5045 setPreferenceProperty( segLen, "min", 1 );
5046 setPreferenceProperty( segLen, "max", 10000000 );
5047 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5048 "SMESH", "nb_segments_per_edge" );
5049 setPreferenceProperty( nbSeg, "min", 1 );
5050 setPreferenceProperty( nbSeg, "max", 10000000 );
5052 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5053 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5054 "SMESH", "forget_mesh_on_hyp_modif" );
5057 // Quantities with individual precision settings
5058 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5059 setPreferenceProperty( precGroup, "columns", 2 );
5061 const int nbQuantities = 6;
5062 int precs[nbQuantities], ii = 0;
5063 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5064 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5065 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5066 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5067 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5068 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5069 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5070 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5071 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5072 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5073 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5074 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5076 // Set property for precision value for spinboxes
5077 for ( ii = 0; ii < nbQuantities; ii++ ){
5078 setPreferenceProperty( precs[ii], "min", -14 );
5079 setPreferenceProperty( precs[ii], "max", 14 );
5080 setPreferenceProperty( precs[ii], "precision", 2 );
5083 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5084 setPreferenceProperty( previewGroup, "columns", 2 );
5085 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5086 setPreferenceProperty( chunkSize, "min", 1 );
5087 setPreferenceProperty( chunkSize, "max", 1000 );
5088 setPreferenceProperty( chunkSize, "step", 50 );
5090 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5091 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5093 // Mesh tab ------------------------------------------------------------------------
5094 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5095 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5096 setPreferenceProperty( nodeGroup, "columns", 3 );
5098 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5100 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5102 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5103 QList<QVariant> aMarkerTypeIndicesList;
5104 QList<QVariant> aMarkerTypeIconsList;
5105 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5106 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5107 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5108 aMarkerTypeIndicesList << i;
5109 aMarkerTypeIconsList << pixmap;
5111 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5112 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5114 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5116 QList<QVariant> aMarkerScaleIndicesList;
5117 QStringList aMarkerScaleValuesList;
5118 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5119 aMarkerScaleIndicesList << i;
5120 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5122 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5123 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5125 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5126 //setPreferenceProperty( elemGroup, "columns", 2 );
5128 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5129 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5130 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5131 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5132 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5133 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5134 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5135 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5136 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5139 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5140 setPreferenceProperty( grpGroup, "columns", 2 );
5142 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5143 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5145 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5146 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5147 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5148 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5149 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5150 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5151 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5152 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5153 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5154 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5155 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5156 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5157 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5158 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5160 setPreferenceProperty( size0d, "min", 1 );
5161 setPreferenceProperty( size0d, "max", 10 );
5163 // setPreferenceProperty( ballSize, "min", 1 );
5164 // setPreferenceProperty( ballSize, "max", 10 );
5166 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5167 setPreferenceProperty( ballDiameter, "max", 1e9 );
5168 setPreferenceProperty( ballDiameter, "step", 0.1 );
5170 setPreferenceProperty( ballScale, "min", 1e-2 );
5171 setPreferenceProperty( ballScale, "max", 1e7 );
5172 setPreferenceProperty( ballScale, "step", 0.5 );
5174 setPreferenceProperty( elemW, "min", 1 );
5175 setPreferenceProperty( elemW, "max", 5 );
5177 setPreferenceProperty( outW, "min", 1 );
5178 setPreferenceProperty( outW, "max", 5 );
5180 setPreferenceProperty( shrink, "min", 0 );
5181 setPreferenceProperty( shrink, "max", 100 );
5183 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5184 setPreferenceProperty( numGroup, "columns", 2 );
5186 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5187 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5189 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5190 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5192 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5193 setPreferenceProperty( orientGroup, "columns", 1 );
5195 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5196 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5198 setPreferenceProperty( orientScale, "min", 0.05 );
5199 setPreferenceProperty( orientScale, "max", 0.5 );
5200 setPreferenceProperty( orientScale, "step", 0.05 );
5202 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5204 // Selection tab ------------------------------------------------------------------------
5205 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5207 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5208 setPreferenceProperty( selGroup, "columns", 2 );
5210 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5211 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5213 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5214 setPreferenceProperty( preGroup, "columns", 2 );
5216 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5218 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5219 setPreferenceProperty( precSelGroup, "columns", 2 );
5221 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5222 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5223 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5225 // Scalar Bar tab ------------------------------------------------------------------------
5226 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5227 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5228 setPreferenceProperty( fontGr, "columns", 2 );
5230 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5231 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5233 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5234 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5236 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5237 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5239 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5240 setPreferenceProperty( numcol, "min", 2 );
5241 setPreferenceProperty( numcol, "max", 256 );
5243 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5244 setPreferenceProperty( numlab, "min", 2 );
5245 setPreferenceProperty( numlab, "max", 65 );
5247 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5248 setPreferenceProperty( orientGr, "columns", 2 );
5249 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5250 QStringList orients;
5251 orients.append( tr( "SMESH_VERTICAL" ) );
5252 orients.append( tr( "SMESH_HORIZONTAL" ) );
5253 indices.clear(); indices.append( 0 ); indices.append( 1 );
5254 setPreferenceProperty( orient, "strings", orients );
5255 setPreferenceProperty( orient, "indexes", indices );
5257 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5258 setPreferenceProperty( posVSizeGr, "columns", 2 );
5259 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5260 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5261 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5262 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5263 setPreferenceProperty( xv, "step", 0.1 );
5264 setPreferenceProperty( xv, "min", 0.0 );
5265 setPreferenceProperty( xv, "max", 1.0 );
5266 setPreferenceProperty( yv, "step", 0.1 );
5267 setPreferenceProperty( yv, "min", 0.0 );
5268 setPreferenceProperty( yv, "max", 1.0 );
5269 setPreferenceProperty( wv, "step", 0.1 );
5270 setPreferenceProperty( wv, "min", 0.0 );
5271 setPreferenceProperty( wv, "max", 1.0 );
5272 setPreferenceProperty( hv, "min", 0.0 );
5273 setPreferenceProperty( hv, "max", 1.0 );
5274 setPreferenceProperty( hv, "step", 0.1 );
5276 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5277 setPreferenceProperty( posHSizeGr, "columns", 2 );
5278 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5279 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5280 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5281 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5282 setPreferenceProperty( xv, "min", 0.0 );
5283 setPreferenceProperty( xv, "max", 1.0 );
5284 setPreferenceProperty( xv, "step", 0.1 );
5285 setPreferenceProperty( xh, "min", 0.0 );
5286 setPreferenceProperty( xh, "max", 1.0 );
5287 setPreferenceProperty( xh, "step", 0.1 );
5288 setPreferenceProperty( yh, "min", 0.0 );
5289 setPreferenceProperty( yh, "max", 1.0 );
5290 setPreferenceProperty( yh, "step", 0.1 );
5291 setPreferenceProperty( wh, "min", 0.0 );
5292 setPreferenceProperty( wh, "max", 1.0 );
5293 setPreferenceProperty( wh, "step", 0.1 );
5294 setPreferenceProperty( hh, "min", 0.0 );
5295 setPreferenceProperty( hh, "max", 1.0 );
5296 setPreferenceProperty( hh, "step", 0.1 );
5298 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5299 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5300 setPreferenceProperty( distributionGr, "columns", 3 );
5302 types.append( tr( "SMESH_MONOCOLOR" ) );
5303 types.append( tr( "SMESH_MULTICOLOR" ) );
5304 indices.clear(); indices.append( 0 ); indices.append( 1 );
5305 setPreferenceProperty( coloringType, "strings", types );
5306 setPreferenceProperty( coloringType, "indexes", indices );
5307 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5311 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5313 if( sect=="SMESH" ) {
5314 float sbX1,sbY1,sbW,sbH;
5315 float aTol = 1.00000009999999;
5316 std::string aWarning;
5317 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5318 if( name=="selection_object_color" || name=="selection_element_color" ||
5319 name=="highlight_color" ||
5320 name=="selection_precision_node" || name=="selection_precision_element" ||
5321 name=="selection_precision_object")
5322 SMESH::UpdateSelectionProp( this );
5323 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5324 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5325 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5326 if(sbX1+sbW > aTol){
5327 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5330 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5331 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5334 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5335 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5336 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5337 if(sbY1+sbH > aTol){
5338 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5339 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5340 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5343 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5344 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5345 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5346 if(sbX1+sbW > aTol){
5347 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5350 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5351 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5354 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5355 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5356 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5357 if(sbY1+sbH > aTol){
5358 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5361 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5362 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5365 else if ( name == "segmentation" ) {
5366 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5367 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5369 else if ( name == "nb_segments_per_edge" ) {
5370 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5371 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5373 else if ( name == "historical_python_dump" ||
5374 name == "forget_mesh_on_hyp_modif") {
5375 QString val = aResourceMgr->stringValue( "SMESH", name );
5376 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5378 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5379 SMESH::UpdateFontProp( this );
5381 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5382 SMESH::UpdateFontProp( this );
5385 if(aWarning.size() != 0){
5386 aWarning += "The default values are applied instead.";
5387 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5388 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5389 QObject::tr(aWarning.c_str()));
5394 //================================================================================
5396 * \brief Update something in accordance with update flags
5397 * \param theFlags - update flags
5399 * Update viewer or/and object browser etc. in accordance with update flags ( see
5400 * LightApp_UpdateFlags enumeration ).
5402 //================================================================================
5403 void SMESHGUI::update( const int flags )
5405 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5406 SMESH::UpdateView();
5408 SalomeApp_Module::update( flags );
5411 //================================================================================
5413 * \brief Set default selection mode
5415 * SLOT called when operation commited. Sets default selection mode
5417 //================================================================================
5418 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5420 SVTK_ViewWindow* vtkWnd =
5421 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5423 vtkWnd->SetSelectionMode( ActorSelection );
5426 //================================================================================
5428 * \brief Set default selection mode
5430 * SLOT called when operation aborted. Sets default selection mode
5432 //================================================================================
5433 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5435 SVTK_ViewWindow* vtkWnd =
5436 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5438 vtkWnd->SetSelectionMode( ActorSelection );
5441 //================================================================================
5443 * \brief Creates operation with given identifier
5444 * \param id - identifier of operation to be started
5445 * \return Pointer on created operation or NULL if operation is not created
5447 * Virtual method redefined from the base class creates operation with given id.
5448 * It is called called automatically from startOperation method of base class.
5450 //================================================================================
5451 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5453 LightApp_Operation* op = 0;
5454 // to do : create operation here
5457 case SMESHOp::OpConvertMeshToQuadratic:
5458 op = new SMESHGUI_ConvToQuadOp();
5460 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5461 op = new SMESHGUI_Make2DFrom3DOp();
5463 case SMESHOp::OpReorientFaces:
5464 op = new SMESHGUI_ReorientFacesOp();
5466 case SMESHOp::OpCreateMesh:
5467 op = new SMESHGUI_MeshOp( true, true );
5469 case SMESHOp::OpCreateSubMesh:
5470 op = new SMESHGUI_MeshOp( true, false );
5472 case SMESHOp::OpEditMeshOrSubMesh:
5473 op = new SMESHGUI_MeshOp( false );
5475 case SMESHOp::OpCompute:
5476 op = new SMESHGUI_ComputeOp();
5478 case SMESHOp::OpPreCompute:
5479 op = new SMESHGUI_PrecomputeOp();
5481 case SMESHOp::OpEvaluate:
5482 op = new SMESHGUI_EvaluateOp();
5484 case SMESHOp::OpMeshOrder:
5485 op = new SMESHGUI_MeshOrderOp();
5487 case SMESHOp::OpCreateGeometryGroup:
5488 op = new SMESHGUI_GroupOnShapeOp();
5490 case SMESHOp::OpFindElementByPoint:
5491 op = new SMESHGUI_FindElemByPointOp();
5493 case SMESHOp::OpMoveNode: // Make mesh pass through point
5494 op = new SMESHGUI_MakeNodeAtPointOp();
5496 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5497 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5504 op = SalomeApp_Module::createOperation( id );
5508 //================================================================================
5510 * \brief Stops current operations and starts a given one
5511 * \param id - The id of the operation to start
5513 //================================================================================
5515 void SMESHGUI::switchToOperation(int id)
5517 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5518 activeStudy()->abortAllOperations();
5519 startOperation( id );
5522 LightApp_Displayer* SMESHGUI::displayer()
5525 myDisplayer = new SMESHGUI_Displayer( getApp() );
5529 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5532 int aTolerance = 64;
5533 int anIterations = 0;
5539 if( anIterations % aPeriod == 0 )
5542 if( aTolerance < 1 )
5546 aHue = (int)( 360.0 * rand() / RAND_MAX );
5549 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5550 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5551 for( ; it != itEnd; ++it )
5553 SALOMEDS::Color anAutoColor = *it;
5554 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5557 aQColor.getHsv( &h, &s, &v );
5558 if( abs( h - aHue ) < aTolerance )
5570 aColor.setHsv( aHue, 255, 255 );
5572 SALOMEDS::Color aSColor;
5573 aSColor.R = aColor.redF();
5574 aSColor.G = aColor.greenF();
5575 aSColor.B = aColor.blueF();
5580 const char* gSeparator = "_"; // character used to separate parameter names
5581 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5582 const char* gPathSep = "|"; // character used to separate paths
5585 * \brief Store visual parameters
5587 * This method is called just before the study document is saved.
5588 * Store visual parameters in AttributeParameter attribue(s)
5590 void SMESHGUI::storeVisualParameters (int savePoint)
5593 Kernel_Utils::Localizer loc;
5595 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5596 if (!appStudy || !appStudy->studyDS())
5598 _PTR(Study) studyDS = appStudy->studyDS();
5600 // componentName is used for encoding of entries when storing them in IParameters
5601 std::string componentName = myComponentSMESH->ComponentDataType();
5602 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5603 //if (!aSComponent) return;
5606 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5607 componentName.c_str(),
5609 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5611 // store map of custom markers
5612 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5613 if( !aMarkerMap.empty() )
5615 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5616 for( ; anIter != aMarkerMap.end(); anIter++ )
5618 int anId = anIter->first;
5619 VTK::MarkerData aMarkerData = anIter->second;
5620 std::string aMarkerFileName = aMarkerData.first;
5621 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5622 if( aMarkerTexture.size() < 3 )
5623 continue; // should contain at least width, height and the first value
5625 QString aPropertyName( "texture" );
5626 aPropertyName += gSeparator;
5627 aPropertyName += QString::number( anId );
5629 QString aPropertyValue = aMarkerFileName.c_str();
5630 aPropertyValue += gPathSep;
5632 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5633 ushort aWidth = *aTextureIter++;
5634 ushort aHeight = *aTextureIter++;
5635 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5636 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5637 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5638 aPropertyValue += QString::number( *aTextureIter );
5640 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5644 // viewers counters are used for storing view_numbers in IParameters
5647 // main cycle to store parameters of displayed objects
5648 QList<SUIT_ViewManager*> lst;
5649 QList<SUIT_ViewManager*>::Iterator it;
5650 getApp()->viewManagers(lst);
5651 for (it = lst.begin(); it != lst.end(); it++)
5653 SUIT_ViewManager* vman = *it;
5654 QString vType = vman->getType();
5656 // saving VTK actors properties
5657 if (vType == SVTK_Viewer::Type())
5659 // store the clipping planes attached to the view manager
5660 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5661 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5662 if( anIter != myClippingPlaneInfoMap.end() )
5663 aClippingPlaneInfoList = anIter->second;
5665 if( !aClippingPlaneInfoList.empty() ) {
5666 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5667 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5669 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5670 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5672 QString aPropertyName( "ClippingPlane" );
5673 aPropertyName += gSeparator;
5674 aPropertyName += QString::number( vtkViewers );
5675 aPropertyName += gSeparator;
5676 aPropertyName += QString::number( anId );
5678 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5679 aPropertyValue += gDigitsSep;
5680 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5681 aPropertyValue += gDigitsSep;
5682 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5683 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5684 aPropertyValue += gDigitsSep;
5685 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5686 aPropertyValue += gDigitsSep;
5687 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5688 aPropertyValue += gDigitsSep;
5689 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5690 aPropertyValue += gDigitsSep;
5691 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5692 aPropertyValue += gDigitsSep;
5693 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5694 aPropertyValue += gDigitsSep;
5695 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5697 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5698 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5699 aPropertyValue += gDigitsSep;
5700 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5701 aPropertyValue += gDigitsSep;
5702 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5703 aPropertyValue += gDigitsSep;
5704 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5707 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5711 QVector<SUIT_ViewWindow*> views = vman->getViews();
5712 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5714 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5716 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5717 vtkActorCollection* allActors = aCopy.GetActors();
5718 allActors->InitTraversal();
5719 while (vtkActor* actor = allActors->GetNextActor())
5721 if (actor->GetVisibility()) // store only visible actors
5723 SMESH_Actor* aSmeshActor = 0;
5724 if (actor->IsA("SMESH_Actor"))
5725 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5726 if (aSmeshActor && aSmeshActor->hasIO())
5728 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5731 // entry is "encoded" = it does NOT contain component adress,
5732 // since it is a subject to change on next component loading
5733 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5735 std::string param, vtkParam = vType.toLatin1().data();
5736 vtkParam += gSeparator;
5737 vtkParam += QString::number(vtkViewers).toLatin1().data();
5738 vtkParam += gSeparator;
5741 param = vtkParam + "Visibility";
5742 ip->setParameter(entry, param, "On");
5745 param = vtkParam + "Representation";
5746 ip->setParameter(entry, param, QString::number
5747 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5750 param = vtkParam + "IsShrunk";
5751 ip->setParameter(entry, param, QString::number
5752 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5754 // Displayed entities
5755 unsigned int aMode = aSmeshActor->GetEntityMode();
5756 bool isE = aMode & SMESH_Actor::eEdges;
5757 bool isF = aMode & SMESH_Actor::eFaces;
5758 bool isV = aMode & SMESH_Actor::eVolumes;
5759 bool is0d = aMode & SMESH_Actor::e0DElements;
5760 bool isB = aMode & SMESH_Actor::eBallElem;
5762 QString modeStr ("e");
5763 modeStr += gDigitsSep; modeStr += QString::number(isE);
5764 modeStr += gDigitsSep; modeStr += "f";
5765 modeStr += gDigitsSep; modeStr += QString::number(isF);
5766 modeStr += gDigitsSep; modeStr += "v";
5767 modeStr += gDigitsSep; modeStr += QString::number(isV);
5768 modeStr += gDigitsSep; modeStr += "0d";
5769 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5770 modeStr += gDigitsSep; modeStr += "b";
5771 modeStr += gDigitsSep; modeStr += QString::number(isB);
5773 param = vtkParam + "Entities";
5774 ip->setParameter(entry, param, modeStr.toLatin1().data());
5780 aSmeshActor->GetSufaceColor(r, g, b, delta);
5781 QStringList colorStr;
5782 colorStr << "surface";
5783 colorStr << QString::number(r);
5784 colorStr << QString::number(g);
5785 colorStr << QString::number(b);
5787 colorStr << "backsurface";
5788 colorStr << QString::number(delta);
5790 aSmeshActor->GetVolumeColor(r, g, b, delta);
5791 colorStr << "volume";
5792 colorStr << QString::number(r);
5793 colorStr << QString::number(g);
5794 colorStr << QString::number(b);
5795 colorStr << QString::number(delta);
5797 aSmeshActor->GetEdgeColor(r, g, b);
5799 colorStr << QString::number(r);
5800 colorStr << QString::number(g);
5801 colorStr << QString::number(b);
5803 aSmeshActor->GetNodeColor(r, g, b);
5805 colorStr << QString::number(r);
5806 colorStr << QString::number(g);
5807 colorStr << QString::number(b);
5809 aSmeshActor->GetOutlineColor(r, g, b);
5810 colorStr << "outline";
5811 colorStr << QString::number(r);
5812 colorStr << QString::number(g);
5813 colorStr << QString::number(b);
5815 aSmeshActor->Get0DColor(r, g, b);
5816 colorStr << "elem0d";
5817 colorStr << QString::number(r);
5818 colorStr << QString::number(g);
5819 colorStr << QString::number(b);
5821 aSmeshActor->GetBallColor(r, g, b);
5823 colorStr << QString::number(r);
5824 colorStr << QString::number(g);
5825 colorStr << QString::number(b);
5827 aSmeshActor->GetFacesOrientationColor(r, g, b);
5828 colorStr << "orientation";
5829 colorStr << QString::number(r);
5830 colorStr << QString::number(g);
5831 colorStr << QString::number(b);
5833 param = vtkParam + "Colors";
5834 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5837 QStringList sizeStr;
5839 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5840 sizeStr << "outline";
5841 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5842 sizeStr << "elem0d";
5843 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5845 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5846 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5847 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5848 sizeStr << "shrink";
5849 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5850 sizeStr << "orientation";
5851 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5852 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5854 param = vtkParam + "Sizes";
5855 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5860 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5861 if( aMarkerType == VTK::MT_USER ) {
5862 markerStr += "custom";
5863 markerStr += gDigitsSep;
5864 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5868 markerStr += gDigitsSep;
5869 markerStr += QString::number( (int)aMarkerType );
5870 markerStr += gDigitsSep;
5871 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5874 param = vtkParam + "PointMarker";
5875 ip->setParameter(entry, param, markerStr.toLatin1().data());
5878 param = vtkParam + "Opacity";
5879 ip->setParameter(entry, param,
5880 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5883 param = vtkParam + "ClippingPlane";
5885 if( !aClippingPlaneInfoList.empty() ) {
5886 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5887 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5889 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5890 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5891 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5892 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5893 if( aSmeshActor == *anIter2 ) {
5894 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5895 QString::number( anId ).toLatin1().constData() );
5902 ip->setParameter( entry, param, "Off" );
5903 } // if (io->hasEntry())
5904 } // SMESH_Actor && hasIO
5906 } // while.. actors traversal
5910 } // if (SVTK view model)
5911 } // for (viewManagers)
5914 // data structures for clipping planes processing
5918 bool isOpenGLClipping;
5919 vtkIdType RelativeOrientation;
5922 int AbsoluteOrientation;
5923 double X, Y, Z, Dx, Dy, Dz;
5925 typedef std::list<TPlaneData> TPlaneDataList;
5926 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5928 typedef std::list<vtkActor*> TActorList;
5931 TActorList ActorList;
5932 SUIT_ViewManager* ViewManager;
5934 typedef std::list<TPlaneInfo> TPlaneInfoList;
5935 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5938 * \brief Restore visual parameters
5940 * This method is called after the study document is opened.
5941 * Restore visual parameters from AttributeParameter attribue(s)
5943 void SMESHGUI::restoreVisualParameters (int savePoint)
5946 Kernel_Utils::Localizer loc;
5948 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5949 if (!appStudy || !appStudy->studyDS())
5951 _PTR(Study) studyDS = appStudy->studyDS();
5953 // componentName is used for encoding of entries when storing them in IParameters
5954 std::string componentName = myComponentSMESH->ComponentDataType();
5955 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5956 //if (!aSComponent) return;
5959 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5960 componentName.c_str(),
5962 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5964 // restore map of custom markers and map of clipping planes
5965 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5966 TPlaneDataMap aPlaneDataMap;
5968 std::vector<std::string> properties = ip->getProperties();
5969 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5971 std::string property = *propIt;
5972 QString aPropertyName( property.c_str() );
5973 QString aPropertyValue( ip->getProperty( property ).c_str() );
5975 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5976 if( aPropertyNameList.isEmpty() )
5979 QString aPropertyType = aPropertyNameList[0];
5980 if( aPropertyType == "texture" )
5982 if( aPropertyNameList.size() != 2 )
5986 int anId = aPropertyNameList[1].toInt( &ok );
5987 if( !ok || anId < 1 )
5990 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5991 if( aPropertyValueList.size() != 2 )
5994 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5995 QString aMarkerTextureString = aPropertyValueList[1];
5996 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5997 if( aMarkerTextureStringList.size() != 3 )
6001 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6006 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6010 VTK::MarkerTexture aMarkerTexture;
6011 aMarkerTexture.push_back( aWidth );
6012 aMarkerTexture.push_back( aHeight );
6014 QString aMarkerTextureData = aMarkerTextureStringList[2];
6015 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6017 QChar aChar = aMarkerTextureData.at( i );
6018 if( aChar.isDigit() )
6019 aMarkerTexture.push_back( aChar.digitValue() );
6022 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6024 else if( aPropertyType == "ClippingPlane" )
6026 if( aPropertyNameList.size() != 3 )
6030 int aViewId = aPropertyNameList[1].toInt( &ok );
6031 if( !ok || aViewId < 0 )
6035 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6036 if( !ok || aClippingPlaneId < 0 )
6039 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6040 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6043 TPlaneData aPlaneData;
6044 aPlaneData.Id = aClippingPlaneId;
6047 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6052 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6056 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6059 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6064 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6069 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6074 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6079 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6084 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6089 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6093 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6095 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6100 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6105 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6110 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6115 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6116 aPlaneDataList.push_back( aPlaneData );
6120 TPlaneInfoMap aPlaneInfoMap;
6122 std::vector<std::string> entries = ip->getEntries();
6124 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6126 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6127 QString entry (ip->decodeEntry(*entIt).c_str());
6129 // Check that the entry corresponds to a real object in the Study
6130 // as the object may be deleted or modified after the visual state is saved.
6131 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6132 if (!so) continue; //Skip the not existent entry
6134 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6135 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6137 std::vector<std::string>::iterator namesIt = paramNames.begin();
6138 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6140 // actors are stored in a map after displaying of them for
6141 // quicker access in the future: map < viewID to actor >
6142 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6144 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6146 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6147 // '_' is used as separator and should not be used in viewer type or parameter names.
6148 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6149 if (lst.size() != 3)
6152 QString viewerTypStr = lst[0];
6153 QString viewIndexStr = lst[1];
6154 QString paramNameStr = lst[2];
6157 int viewIndex = viewIndexStr.toUInt(&ok);
6158 if (!ok) // bad conversion of view index to integer
6162 if (viewerTypStr == SVTK_Viewer::Type())
6164 SMESH_Actor* aSmeshActor = 0;
6165 if (vtkActors.IsBound(viewIndex))
6166 aSmeshActor = vtkActors.Find(viewIndex);
6168 QList<SUIT_ViewManager*> lst;
6169 getApp()->viewManagers(viewerTypStr, lst);
6171 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6172 SUIT_ViewManager* vman = NULL;
6173 if (viewIndex >= 0 && viewIndex < lst.count())
6174 vman = lst.at(viewIndex);
6176 if (paramNameStr == "Visibility")
6178 if (!aSmeshActor && displayer() && vman)
6180 SUIT_ViewModel* vmodel = vman->getViewModel();
6181 // SVTK view model can be casted to SALOME_View
6182 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6184 // store displayed actor in a temporary map for quicker
6185 // access later when restoring other parameters
6186 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6187 vtkRenderer* Renderer = vtkView->getRenderer();
6188 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6189 vtkActorCollection* theActors = aCopy.GetActors();
6190 theActors->InitTraversal();
6191 bool isFound = false;
6192 vtkActor *ac = theActors->GetNextActor();
6193 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6194 if (ac->IsA("SMESH_Actor")) {
6195 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6196 if (aGeomAc->hasIO()) {
6197 Handle(SALOME_InteractiveObject) io =
6198 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6199 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6201 vtkActors.Bind(viewIndex, aGeomAc);
6207 } // if (paramNameStr == "Visibility")
6210 // the rest properties "work" with SMESH_Actor
6213 QString val ((*valuesIt).c_str());
6216 if (paramNameStr == "Representation") {
6217 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6220 else if (paramNameStr == "IsShrunk") {
6222 if (!aSmeshActor->IsShrunk())
6223 aSmeshActor->SetShrink();
6226 if (aSmeshActor->IsShrunk())
6227 aSmeshActor->UnShrink();
6230 // Displayed entities
6231 else if (paramNameStr == "Entities") {
6232 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6233 int aEntityMode = SMESH_Actor::eAllEntity;
6234 for ( int i = 0; i < mode.count(); i+=2 ) {
6235 if ( i < mode.count()-1 ) {
6236 QString type = mode[i];
6237 bool val = mode[i+1].toInt();
6238 if ( type == "e" && !val )
6239 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6240 else if ( type == "f" && !val )
6241 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6242 else if ( type == "v" && !val )
6243 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6244 else if ( type == "0d" && !val )
6245 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6246 else if ( type == "b" && !val )
6247 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6250 aSmeshActor->SetEntityMode( aEntityMode );
6253 else if (paramNameStr == "Colors") {
6254 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6261 QColor outlineColor;
6262 QColor orientationColor;
6268 // below lines are required to get default values for delta coefficients
6269 // of backface color for faces and color of reversed volumes
6270 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6271 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6272 for ( int i = 0; i < colors.count(); i++ ) {
6273 QString type = colors[i];
6274 if ( type == "surface" ) {
6275 // face color is set by 3 values r:g:b, where
6276 // - r,g,b - is rgb color components
6277 if ( i+1 >= colors.count() ) break; // format error
6278 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6279 if ( i+2 >= colors.count() ) break; // format error
6280 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6281 if ( i+3 >= colors.count() ) break; // format error
6282 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6283 faceColor.setRgbF( r, g, b );
6286 else if ( type == "backsurface" ) {
6287 // backface color can be defined in several ways
6288 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6289 // - in latest versions, it is set as delta coefficient
6290 bool rgbOk = false, deltaOk;
6291 if ( i+1 >= colors.count() ) break; // format error
6292 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6293 int delta = colors[i+1].toInt( &deltaOk );
6295 if ( i+1 < colors.count() ) // index is shifted to 1
6296 g = colors[i+1].toDouble( &rgbOk );
6297 if ( rgbOk ) i++; // shift index
6298 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6299 b = colors[i+1].toDouble( &rgbOk );
6301 // - as currently there's no way to set directly backsurface color as it was before,
6302 // we ignore old dump where r,g,b triple was set
6303 // - also we check that delta parameter is set properly
6304 if ( !rgbOk && deltaOk )
6307 else if ( type == "volume" ) {
6308 // volume color is set by 4 values r:g:b:delta, where
6309 // - r,g,b - is a normal volume rgb color components
6310 // - delta - is a reversed volume color delta coefficient
6311 if ( i+1 >= colors.count() ) break; // format error
6312 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6313 if ( i+2 >= colors.count() ) break; // format error
6314 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6315 if ( i+3 >= colors.count() ) break; // format error
6316 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6317 if ( i+4 >= colors.count() ) break; // format error
6318 int delta = colors[i+4].toInt( &bOk );
6319 if ( !bOk ) break; // format error
6320 volumeColor.setRgbF( r, g, b );
6324 else if ( type == "edge" ) {
6325 // edge color is set by 3 values r:g:b, where
6326 // - r,g,b - is rgb color components
6327 if ( i+1 >= colors.count() ) break; // format error
6328 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6329 if ( i+2 >= colors.count() ) break; // format error
6330 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6331 if ( i+3 >= colors.count() ) break; // format error
6332 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6333 edgeColor.setRgbF( r, g, b );
6336 else if ( type == "node" ) {
6337 // node color is set by 3 values r:g:b, where
6338 // - r,g,b - is rgb color components
6339 if ( i+1 >= colors.count() ) break; // format error
6340 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6341 if ( i+2 >= colors.count() ) break; // format error
6342 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6343 if ( i+3 >= colors.count() ) break; // format error
6344 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6345 nodeColor.setRgbF( r, g, b );
6348 else if ( type == "elem0d" ) {
6349 // 0d element color is set by 3 values r:g:b, where
6350 // - r,g,b - is rgb color components
6351 if ( i+1 >= colors.count() ) break; // format error
6352 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6353 if ( i+2 >= colors.count() ) break; // format error
6354 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6355 if ( i+3 >= colors.count() ) break; // format error
6356 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6357 elem0dColor.setRgbF( r, g, b );
6360 else if ( type == "ball" ) {
6361 // ball color is set by 3 values r:g:b, where
6362 // - r,g,b - is rgb color components
6363 if ( i+1 >= colors.count() ) break; // format error
6364 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6365 if ( i+2 >= colors.count() ) break; // format error
6366 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6367 if ( i+3 >= colors.count() ) break; // format error
6368 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6369 ballColor.setRgbF( r, g, b );
6372 else if ( type == "outline" ) {
6373 // outline color is set by 3 values r:g:b, where
6374 // - r,g,b - is rgb color components
6375 if ( i+1 >= colors.count() ) break; // format error
6376 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6377 if ( i+2 >= colors.count() ) break; // format error
6378 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6379 if ( i+3 >= colors.count() ) break; // format error
6380 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6381 outlineColor.setRgbF( r, g, b );
6384 else if ( type == "orientation" ) {
6385 // orientation color is set by 3 values r:g:b, where
6386 // - r,g,b - is rgb color components
6387 if ( i+1 >= colors.count() ) break; // format error
6388 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6389 if ( i+2 >= colors.count() ) break; // format error
6390 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6391 if ( i+3 >= colors.count() ) break; // format error
6392 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6393 orientationColor.setRgbF( r, g, b );
6398 if ( nodeColor.isValid() )
6399 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6401 if ( edgeColor.isValid() )
6402 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6404 if ( faceColor.isValid() )
6405 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6407 if ( volumeColor.isValid() )
6408 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6409 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6410 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6412 if ( elem0dColor.isValid() )
6413 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6415 if ( ballColor.isValid() )
6416 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6418 if ( outlineColor.isValid() )
6419 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6420 // orientation color
6421 if ( orientationColor.isValid() )
6422 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6425 else if (paramNameStr == "Sizes") {
6426 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6429 int outlineWidth = -1;
6430 int elem0dSize = -1;
6431 //int ballSize = -1;
6432 double ballDiameter = -1.0;
6433 double ballScale = -1.0;
6434 double shrinkSize = -1;
6435 double orientationSize = -1;
6436 bool orientation3d = false;
6437 for ( int i = 0; i < sizes.count(); i++ ) {
6438 QString type = sizes[i];
6439 if ( type == "line" ) {
6440 // line (wireframe) width is given as single integer value
6441 if ( i+1 >= sizes.count() ) break; // format error
6442 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6446 if ( type == "outline" ) {
6447 // outline width is given as single integer value
6448 if ( i+1 >= sizes.count() ) break; // format error
6449 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6453 else if ( type == "elem0d" ) {
6454 // 0d element size is given as single integer value
6455 if ( i+1 >= sizes.count() ) break; // format error
6456 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6460 else if ( type == "ball" ) {
6461 // balls are specified by two values: size:scale, where
6462 // - size - is a integer value specifying size
6463 // - scale - is a double value specifying scale factor
6464 if ( i+1 >= sizes.count() ) break; // format error
6465 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6466 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6467 if ( i+2 >= sizes.count() ) break; // format error
6468 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6474 else if ( type == "shrink" ) {
6475 // shrink factor is given as single floating point value
6476 if ( i+1 >= sizes.count() ) break; // format error
6477 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6481 else if ( type == "orientation" ) {
6482 // orientation vectors are specified by two values size:3d, where
6483 // - size - is a floating point value specifying scale factor
6484 // - 3d - is a boolean
6485 if ( i+1 >= sizes.count() ) break; // format error
6486 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6487 if ( i+2 >= sizes.count() ) break; // format error
6488 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6489 orientationSize = v1;
6490 orientation3d = (bool)v2;
6494 // line (wireframe) width
6495 if ( lineWidth > 0 )
6496 aSmeshActor->SetLineWidth( lineWidth );
6498 if ( outlineWidth > 0 )
6499 aSmeshActor->SetOutlineWidth( outlineWidth );
6500 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6501 aSmeshActor->SetOutlineWidth( lineWidth );
6503 if ( elem0dSize > 0 )
6504 aSmeshActor->Set0DSize( elem0dSize );
6506 /*if ( ballSize > 0 )
6507 aSmeshActor->SetBallSize( ballSize );*/
6509 if ( ballDiameter > 0 )
6510 aSmeshActor->SetBallSize( ballDiameter );
6512 if ( ballScale > 0.0 )
6513 aSmeshActor->SetBallScale( ballScale );
6515 if ( shrinkSize > 0 )
6516 aSmeshActor->SetShrinkFactor( shrinkSize );
6517 // orientation vectors
6518 if ( orientationSize > 0 ) {
6519 aSmeshActor->SetFacesOrientationScale( orientationSize );
6520 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6524 else if (paramNameStr == "PointMarker") {
6525 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6526 if( data.count() >= 2 ) {
6528 int aParam1 = data[1].toInt( &ok );
6530 if( data[0] == "std" && data.count() == 3 ) {
6531 int aParam2 = data[2].toInt( &ok );
6532 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6534 else if( data[0] == "custom" ) {
6535 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6536 if( markerIt != aMarkerMap.end() ) {
6537 VTK::MarkerData aMarkerData = markerIt->second;
6538 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6545 else if (paramNameStr == "Opacity") {
6546 aSmeshActor->SetOpacity(val.toFloat());
6549 else if (paramNameStr.startsWith("ClippingPlane")) {
6550 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6551 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6552 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6553 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6554 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6555 // new format - val looks like "Off" or "0" (plane id)
6556 // (note: in new format "Off" value is used only for consistency,
6557 // so it is processed together with values in old format)
6558 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6559 if( anIsOldFormat ) {
6560 if (paramNameStr == "ClippingPlane1" || val == "Off")
6561 aSmeshActor->RemoveAllClippingPlanes();
6563 QList<SUIT_ViewManager*> lst;
6564 getApp()->viewManagers(viewerTypStr, lst);
6565 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6566 if (viewIndex >= 0 && viewIndex < lst.count()) {
6567 SUIT_ViewManager* vman = lst.at(viewIndex);
6568 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6570 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6572 SMESH::TActorList anActorList;
6573 anActorList.push_back( aSmeshActor );
6574 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6575 aPlane->myViewWindow = vtkView;
6576 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6577 aPlane->PlaneMode = aMode;
6578 bool isOpenGLClipping = ( bool )vals[1].toInt();
6579 aPlane->IsOpenGLClipping = isOpenGLClipping;
6580 if ( aMode == SMESH::Absolute ) {
6581 aPlane->myAbsoluteOrientation = vals[2].toInt();
6582 aPlane->X = vals[3].toFloat();
6583 aPlane->Y = vals[4].toFloat();
6584 aPlane->Z = vals[5].toFloat();
6585 aPlane->Dx = vals[6].toFloat();
6586 aPlane->Dy = vals[7].toFloat();
6587 aPlane->Dz = vals[8].toFloat();
6589 else if ( aMode == SMESH::Relative ) {
6590 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6591 aPlane->myDistance = vals[3].toFloat();
6592 aPlane->myAngle[0] = vals[4].toFloat();
6593 aPlane->myAngle[1] = vals[5].toFloat();
6597 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6598 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6599 aClippingPlaneInfo.Plane = aPlane;
6600 aClippingPlaneInfo.ActorList = anActorList;
6601 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6609 int aPlaneId = val.toInt( &ok );
6610 if( ok && aPlaneId >= 0 ) {
6611 bool anIsDefinedPlane = false;
6612 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6613 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6614 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6615 TPlaneInfo& aPlaneInfo = *anIter;
6616 if( aPlaneInfo.PlaneId == aPlaneId ) {
6617 aPlaneInfo.ActorList.push_back( aSmeshActor );
6618 anIsDefinedPlane = true;
6622 if( !anIsDefinedPlane ) {
6623 TPlaneInfo aPlaneInfo;
6624 aPlaneInfo.PlaneId = aPlaneId;
6625 aPlaneInfo.ActorList.push_back( aSmeshActor );
6626 aPlaneInfo.ViewManager = vman;
6628 // to make the list sorted by plane id
6629 anIter = aPlaneInfoList.begin();
6630 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6631 const TPlaneInfo& aPlaneInfoRef = *anIter;
6632 if( aPlaneInfoRef.PlaneId > aPlaneId )
6635 aPlaneInfoList.insert( anIter, aPlaneInfo );
6640 } // if (aSmeshActor)
6641 } // other parameters than Visibility
6643 } // for names/parameters iterator
6644 } // for entries iterator
6646 // take into account planes with empty list of actors referred to them
6647 QList<SUIT_ViewManager*> aVMList;
6648 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6650 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6651 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6652 int aViewId = aPlaneDataIter->first;
6653 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6654 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6656 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6658 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6659 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6660 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6661 const TPlaneData& aPlaneData = *anIter2;
6662 int aPlaneId = aPlaneData.Id;
6664 bool anIsFound = false;
6665 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6666 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6667 const TPlaneInfo& aPlaneInfo = *anIter3;
6668 if( aPlaneInfo.PlaneId == aPlaneId ) {
6675 TPlaneInfo aPlaneInfo; // ActorList field is empty
6676 aPlaneInfo.PlaneId = aPlaneId;
6677 aPlaneInfo.ViewManager = aViewManager;
6679 // to make the list sorted by plane id
6680 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6681 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6682 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6683 if( aPlaneInfoRef.PlaneId > aPlaneId )
6686 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6692 // add clipping planes to actors according to the restored parameters
6693 // and update the clipping plane map
6694 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6695 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6696 int aViewId = anIter1->first;
6697 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6699 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6700 if( anIter2 == aPlaneDataMap.end() )
6702 const TPlaneDataList& aPlaneDataList = anIter2->second;
6704 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6705 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6706 const TPlaneInfo& aPlaneInfo = *anIter3;
6707 int aPlaneId = aPlaneInfo.PlaneId;
6708 const TActorList& anActorList = aPlaneInfo.ActorList;
6709 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6713 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6717 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6719 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6720 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6721 const TPlaneData& aPlaneData = *anIter4;
6722 if( aPlaneData.Id == aPlaneId ) {
6723 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6724 aPlane->myViewWindow = aViewWindow;
6725 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6726 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6727 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6728 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6729 aPlane->X = aPlaneData.X;
6730 aPlane->Y = aPlaneData.Y;
6731 aPlane->Z = aPlaneData.Z;
6732 aPlane->Dx = aPlaneData.Dx;
6733 aPlane->Dy = aPlaneData.Dy;
6734 aPlane->Dz = aPlaneData.Dz;
6736 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6737 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6738 aPlane->myDistance = aPlaneData.Distance;
6739 aPlane->myAngle[0] = aPlaneData.Angle[0];
6740 aPlane->myAngle[1] = aPlaneData.Angle[1];
6743 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6744 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6745 aClippingPlaneInfo.Plane = aPlane;
6746 aClippingPlaneInfo.ActorList = anActorList;
6747 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6758 // update all VTK views
6759 QList<SUIT_ViewManager*> lst;
6760 getApp()->viewManagers(lst);
6761 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6762 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6763 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6764 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6765 // set OpenGL clipping planes
6766 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6767 vtkActorCollection* anAllActors = aCopy.GetActors();
6768 anAllActors->InitTraversal();
6769 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6770 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6771 anActor->SetOpenGLClippingPlane();
6773 vtkView->getRenderer()->ResetCameraClippingRange();
6780 \brief Adds preferences for dfont of VTK viewer
6782 \param pIf group identifier
6783 \param param parameter
6784 \return identifier of preferences
6786 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6788 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6790 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6793 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6794 fam.append( tr( "SMESH_FONT_COURIER" ) );
6795 fam.append( tr( "SMESH_FONT_TIMES" ) );
6797 setPreferenceProperty( tfont, "fonts", fam );
6799 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6800 if ( needSize ) f = f | QtxFontEdit::Size;
6801 setPreferenceProperty( tfont, "features", f );
6807 \brief Actions after hypothesis edition
6808 Updates object browser after hypothesis edition
6810 void SMESHGUI::onHypothesisEdit( int result )
6813 SMESHGUI::Modified();
6814 updateObjBrowser( true );
6819 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6820 \param pview view being closed
6822 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6823 #ifndef DISABLE_PLOT2DVIEWER
6824 //Crear all Plot2d Viewers if need.
6825 SMESH::ClearPlot2Viewers(pview);
6829 void SMESHGUI::message( const QString& msg )
6832 QStringList data = msg.split("/");
6833 if ( data.count() > 0 ) {
6834 if ( data.first() == "mesh_loading" ) {
6836 QString entry = data.count() > 1 ? data[1] : QString();
6837 if ( entry.isEmpty() )
6840 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6842 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6845 name = SMESH::fromUtf8(obj->GetName());
6846 if ( name.isEmpty() )
6849 if ( data.last() == "stop" )
6850 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6852 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6853 QApplication::processEvents();
6859 \brief Connects or disconnects signals about activating and cloning view on the module slots
6860 \param pview view which is connected/disconnected
6862 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6866 SUIT_ViewManager* viewMgr = pview->getViewManager();
6868 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6869 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6871 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6872 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6877 \brief Return \c true if object can be renamed
6879 bool SMESHGUI::renameAllowed( const QString& entry) const {
6880 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6884 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6888 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6893 if(appStudy->isComponent(entry) || obj->isReference())
6896 // check type to prevent renaming of inappropriate objects
6897 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6898 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6899 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6900 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6901 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6902 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6909 Rename object by entry.
6910 \param entry entry of the object
6911 \param name new name of the object
6912 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6914 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6916 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6920 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6925 _PTR(Study) aStudy = appStudy->studyDS();
6930 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6932 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6937 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6938 _PTR(GenericAttribute) anAttr;
6939 _PTR(AttributeName) aName;
6941 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6943 // check type to prevent renaming of inappropriate objects
6944 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6945 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6946 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6947 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6948 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6949 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6950 if ( !name.isEmpty() ) {
6951 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6953 // update name of group object and its actor
6954 Handle(SALOME_InteractiveObject) IObject =
6955 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6957 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6958 if( !aGroupObject->_is_nil() ) {
6959 aGroupObject->SetName( qPrintable(name) );
6960 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6961 anActor->setName( qPrintable(name) );
6971 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6973 static QList<QColor> colors;
6975 if ( colors.isEmpty() ) {
6977 for (int s = 0; s < 2 ; s++)
6979 for (int v = 100; v >= 40; v = v - 20)
6981 for (int h = 0; h < 359 ; h = h + 60)
6983 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6988 static int currentColor = randomize( colors.size() );
6990 SALOMEDS::Color color;
6991 color.R = (double)colors[currentColor].red() / 255.0;
6992 color.G = (double)colors[currentColor].green() / 255.0;
6993 color.B = (double)colors[currentColor].blue() / 255.0;
6995 currentColor = (currentColor+1) % colors.count();