1 // Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
86 #include "SMESHGUI_FilterUtils.h"
87 #include "SMESHGUI_GEOMGenUtils.h"
88 #include "SMESHGUI_GroupUtils.h"
89 #include "SMESHGUI_HypothesesUtils.h"
90 #include "SMESHGUI_MeshUtils.h"
91 #include "SMESHGUI_PatternUtils.h"
92 #include "SMESHGUI_Utils.h"
93 #include "SMESHGUI_VTKUtils.h"
95 #include "SMESH_version.h"
97 #include "SMESH_ControlsDef.hxx"
98 #include "SMESH_Actor.h"
99 #include "SMESH_ActorUtils.h"
100 #include "SMESH_Client.hxx"
101 #include "SMESH_ScalarBarActor.h"
102 #include "SMESH_TypeFilter.hxx"
104 // SALOME GUI includes
105 #include <SalomeApp_Application.h>
106 #include <SalomeApp_CheckFileDlg.h>
107 #include <SalomeApp_DataObject.h>
108 #include <SalomeApp_Study.h>
109 #include <SalomeApp_Tools.h>
111 #include <LightApp_DataOwner.h>
112 #include <LightApp_NameDlg.h>
113 #include <LightApp_Preferences.h>
114 #include <LightApp_SelectionMgr.h>
115 #include <LightApp_UpdateFlags.h>
117 #include <SVTK_ViewManager.h>
118 #include <SVTK_ViewModel.h>
119 #include <SVTK_ViewWindow.h>
121 #include <VTKViewer_Algorithm.h>
123 #include <PyInterp_Interp.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
157 #include <boost/shared_ptr.hpp>
160 #include <vtkCallbackCommand.h>
161 #include <vtkCamera.h>
162 #include <vtkLookupTable.h>
163 #include <vtkPlane.h>
164 #include <vtkRenderer.h>
166 // SALOME KERNEL includes
167 #include <SALOMEDSClient_ClientFactory.hxx>
168 #include <SALOMEDSClient_IParameters.hxx>
169 #include <SALOMEDSClient_SComponent.hxx>
170 #include <SALOMEDSClient_StudyBuilder.hxx>
171 #include <SALOMEDS_Study.hxx>
172 #include <SALOMEDS_SObject.hxx>
173 #include "utilities.h"
176 #include <Standard_ErrorHandler.hxx>
177 #include <NCollection_DataMap.hxx>
179 #include <Basics_Utils.hxx>
181 //To disable automatic genericobj management, the following line should be commented.
182 //Otherwise, it should be uncommented.
183 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
184 #define WITHGENERICOBJ
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ) {
219 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
220 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
222 else if ( theCommandID == SMESHOp::OpImportUNV ) {
223 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
225 else if ( theCommandID == SMESHOp::OpImportDAT ) {
226 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
228 else if ( theCommandID == SMESHOp::OpImportSTL ) {
229 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
232 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
233 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
236 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
237 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
238 filter.append( QObject::tr( "All files (*)" ) );
240 else if ( theCommandID == SMESHOp::OpImportGMF ) {
241 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
242 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
245 QString anInitialPath = "";
246 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
247 anInitialPath = QDir::currentPath();
249 QStringList filenames;
250 bool toCreateGroups = true;
252 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
253 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
254 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
255 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
256 // fd->setNameFilters( filter );
257 // fd->SetChecked( true );
259 // filenames << fd->selectedFile();
260 // toCreateGroups = fd->IsChecked();
266 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
269 QObject::tr( "SMESH_IMPORT_MESH" ) );
271 if ( filenames.count() > 0 ) {
272 SUIT_OverrideCursor wc;
273 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
276 QStringList anEntryList;
277 bool isEmpty = false;
278 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
279 QString filename = *it;
280 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
282 switch ( theCommandID ) {
283 case SMESHOp::OpImportDAT:
285 // DAT format (currently unsupported)
286 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
287 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
290 case SMESHOp::OpImportUNV:
293 aMeshes->length( 1 );
294 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
295 if ( aMeshes[0]->_is_nil() )
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
300 case SMESHOp::OpImportMED:
303 SMESH::DriverMED_ReadStatus res;
304 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
305 if ( res != SMESH::DRS_OK ) {
306 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
307 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
311 case SMESHOp::OpImportSTL:
314 aMeshes->length( 1 );
315 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
316 if ( aMeshes[0]->_is_nil() ) {
317 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
318 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
323 case SMESHOp::OpImportCGNS:
326 SMESH::DriverMED_ReadStatus res;
327 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
328 if ( res != SMESH::DRS_OK ) {
329 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
330 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
335 case SMESHOp::OpImportSAUV:
338 SMESH::DriverMED_ReadStatus res;
339 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
340 if ( res != SMESH::DRS_OK ) {
341 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
342 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
346 case SMESHOp::OpImportGMF:
349 SMESH::ComputeError_var res;
350 aMeshes->length( 1 );
351 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
354 if ( res->code != SMESH::DRS_OK ) {
355 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
356 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
357 if ( strlen( res->comment.in() ) > 0 ) {
358 errors.back() += ": ";
359 errors.back() += res->comment.in();
366 catch ( const SALOME::SALOME_Exception& S_ex ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
371 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
372 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
374 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
375 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
376 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
377 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
378 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
380 anEntryList.append( aMeshSO->GetID().c_str() );
388 // update Object browser
389 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
391 // browse to the published meshes
392 if( LightApp_Application* anApp =
393 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
394 anApp->browseObjects( anEntryList );
396 // show Error message box if there were errors
397 if ( errors.count() > 0 ) {
398 SUIT_MessageBox::critical( SMESHGUI::desktop(),
399 QObject::tr( "SMESH_ERROR" ),
400 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
403 // show warning message box, if some imported mesh is empty
405 SUIT_MessageBox::warning( SMESHGUI::desktop(),
406 QObject::tr( "SMESH_WRN_WARNING" ),
407 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
412 //================================================================================
414 * \brief Export selected meshes or groups into a file
416 //================================================================================
418 void ExportMeshToFile( int theCommandID )
420 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
421 SALOME_ListIO selected;
423 aSel->selectedObjects( selected );
425 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
426 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
427 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
428 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
430 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
432 const bool isCGNS= false;
434 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
435 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
437 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
438 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
441 // get mesh object from selection and check duplication of their names
442 bool hasDuplicatedMeshNames = false;
443 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
444 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
445 SALOME_ListIteratorOfListIO It( selected );
446 for( ; It.More(); It.Next() )
448 Handle(SALOME_InteractiveObject) anIObject = It.Value();
449 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
450 if ( aMeshItem->_is_nil() ) {
451 SUIT_MessageBox::warning( SMESHGUI::desktop(),
452 QObject::tr( "SMESH_WRN_WARNING" ),
453 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
457 QString aMeshName = anIObject->getName();
459 // check for name duplications
460 if ( !hasDuplicatedMeshNames )
461 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
462 if( aMeshName == (*aMeshIter).second ) {
463 hasDuplicatedMeshNames = true;
468 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
471 if( hasDuplicatedMeshNames && isMED ) {
472 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
473 QObject::tr("SMESH_WRN_WARNING"),
474 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
475 QObject::tr("SMESH_BUT_YES"),
476 QObject::tr("SMESH_BUT_NO"), 0, 1);
481 aMeshIter = aMeshList.begin();
482 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
483 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
484 QString aMeshName = (*aMeshIter).second;
486 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
488 // check for equal group names within each mesh
489 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
490 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
491 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
492 int aRet = SUIT_MessageBox::warning
493 (SMESHGUI::desktop(),
494 QObject::tr("SMESH_WRN_WARNING"),
495 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
496 QObject::tr("SMESH_BUT_YES"),
497 QObject::tr("SMESH_BUT_NO"), 0, 1);
504 // Warn the user about presence of not supported elements
506 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
510 notSupportedElemTypes.push_back( SMESH::Entity_0D );
511 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
516 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
517 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
518 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
519 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
520 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
521 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
522 notSupportedElemTypes.push_back( SMESH::Entity_0D );
523 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
528 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
529 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
530 notSupportedElemTypes.push_back( SMESH::Entity_0D );
531 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
536 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
537 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
542 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
543 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
544 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
545 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
546 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
547 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
548 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
553 notSupportedElemTypes.push_back( SMESH::Entity_0D );
554 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
558 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
563 if ( ! notSupportedElemTypes.empty() )
565 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
566 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
567 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
568 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
570 if ( !presentNotSupported.empty() )
573 const char* typeMsg[SMESH::Entity_Last] = {
574 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
575 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
576 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
577 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
578 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
579 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
580 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
581 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
583 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
584 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
585 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
586 if ( iType != presentNotSupported.size() - 1 )
587 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
589 int aRet = SUIT_MessageBox::warning
590 (SMESHGUI::desktop(),
591 QObject::tr("SMESH_WRN_WARNING"),
592 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
593 QObject::tr("SMESH_BUT_YES"),
594 QObject::tr("SMESH_BUT_NO"), 0, 1);
599 // Get parameters of export operation
602 SMESH::MED_VERSION aFormat;
603 // Init the parameters with the default values
604 bool aIsASCII_STL = true;
605 bool toCreateGroups = false;
606 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
608 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
609 bool toOverwrite = true;
610 bool toFindOutDim = true;
612 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
613 QString anInitialPath = "";
614 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
615 anInitialPath = QDir::currentPath();
617 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
619 // Get a file name to write in and additional otions
620 if ( isUNV || isDAT || isGMF ) // Export w/o options
623 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
625 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
627 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
628 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
629 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
630 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
631 anInitialPath + QString("/") + aMeshName,
632 aFilter, aTitle, false);
634 else if ( isCGNS )// Export to CGNS
636 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
637 fd->setWindowTitle( aTitle );
638 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
639 if ( !anInitialPath.isEmpty() )
640 fd->setDirectory( anInitialPath );
641 fd->selectFile(aMeshName);
642 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
643 fd->setValidator( fv );
646 aFilename = fd->selectedFile();
647 toOverwrite = fv->isOverwrite();
651 else if ( isSTL ) // Export to STL
653 QMap<QString, int> aFilterMap;
654 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
655 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
658 QMap<QString, int>::const_iterator it = aFilterMap.begin();
659 for ( ; it != aFilterMap.end(); ++it )
660 filters.push_back( it.key() );
662 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
663 fd->setWindowTitle( aTitle );
664 fd->setNameFilters( filters );
665 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
666 if ( !anInitialPath.isEmpty() )
667 fd->setDirectory( anInitialPath );
668 fd->selectFile(aMeshName);
672 aFilename = fd->selectedFile();
673 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
678 else if ( isMED || isSAUV ) // Export to MED or SAUV
680 QMap<QString, SMESH::MED_VERSION> aFilterMap;
681 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
683 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
684 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
685 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
688 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
689 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
690 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
694 QString aDefaultFilter;
695 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
696 for ( ; it != aFilterMap.end(); ++it ) {
697 filters.push_back( it.key() );
698 if (it.value() == SMESH::MED_V2_2)
699 aDefaultFilter = it.key();
701 QStringList checkBoxes;
702 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
704 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
705 QList< QWidget* > wdgList;
706 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
707 wdgList.append( fieldSelWdg );
709 SalomeApp_CheckFileDlg* fd =
710 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
711 fd->setWindowTitle( aTitle );
712 fd->setNameFilters( filters );
713 fd->selectNameFilter( aDefaultFilter );
714 fd->SetChecked( toCreateGroups, 0 );
715 fd->SetChecked( toFindOutDim, 1 );
716 if ( !anInitialPath.isEmpty() )
717 fd->setDirectory( anInitialPath );
718 fd->selectFile(aMeshName);
721 QListView *lview = fd->findChild<QListView*>("listView");
723 lview->setMinimumHeight(200);
725 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
727 tview->setMinimumHeight(200);
730 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
731 fd->setValidator( fv );
736 aFilename = fd->selectedFile();
738 aFilename = QString::null;
741 aFormat = aFilterMap[fd->selectedNameFilter()];
742 toOverwrite = fv->isOverwrite();
744 if ( !aFilename.isEmpty() ) {
745 // med-2.1 does not support poly elements
746 if ( aFormat==SMESH::MED_V2_1 )
747 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
748 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
749 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
750 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
751 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
753 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
754 QObject::tr("SMESH_WRN_WARNING"),
755 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
756 QObject::tr("SMESH_BUT_YES"),
757 QObject::tr("SMESH_BUT_NO"), 0, 1);
765 // can't append to an existing using other format
766 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
767 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
768 if( !isVersionOk || aVersion != aFormat ) {
769 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
770 QObject::tr("SMESH_WRN_WARNING"),
771 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
772 QObject::tr("SMESH_BUT_YES"),
773 QObject::tr("SMESH_BUT_NO"), 0, 1);
780 QStringList aMeshNamesCollisionList;
781 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
782 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
783 QString anExistingMeshName( aMeshNames[ i ] );
784 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
785 QString anExportMeshName = (*aMeshIter).second;
786 if( anExportMeshName == anExistingMeshName ) {
787 aMeshNamesCollisionList.append( anExportMeshName );
792 if( !aMeshNamesCollisionList.isEmpty() ) {
793 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
794 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
795 QObject::tr("SMESH_WRN_WARNING"),
796 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
797 QObject::tr("SMESH_BUT_YES"),
798 QObject::tr("SMESH_BUT_NO"),
799 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
808 toCreateGroups = fd->IsChecked(0);
809 toFindOutDim = fd->IsChecked(1);
810 fieldSelWdg->GetSelectedFeilds();
811 if ( !fieldSelWdg->parent() )
822 if ( !aFilename.isEmpty() ) {
823 // Check whether the file already exists and delete it if yes
824 QFile aFile( aFilename );
825 if ( aFile.exists() && toOverwrite )
827 SUIT_OverrideCursor wc;
830 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
831 // bool Renumber = false;
832 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
834 // Renumber= resMgr->booleanValue("renumbering");
836 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
837 // aMeshEditor->RenumberNodes();
838 // aMeshEditor->RenumberElements();
839 // if ( SMESHGUI::automaticUpdate() )
840 // SMESH::UpdateView();
844 aMeshIter = aMeshList.begin();
845 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
847 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
848 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
849 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
850 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
851 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
852 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
853 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
854 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
856 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
857 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
858 fields, geoAssFields.toLatin1().data() );
863 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
865 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
866 if( !aMeshItem->_is_nil() )
867 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
872 if ( aMeshOrGroup->_is_equivalent( aMesh ))
873 aMesh->ExportDAT( aFilename.toUtf8().data() );
875 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
879 if ( aMeshOrGroup->_is_equivalent( aMesh ))
880 aMesh->ExportUNV( aFilename.toUtf8().data() );
882 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
886 if ( aMeshOrGroup->_is_equivalent( aMesh ))
887 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
889 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
893 aMeshIter = aMeshList.begin();
894 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
896 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
897 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
898 aMeshItem->ExportCGNS( aMeshOrGroup,
899 aFilename.toUtf8().data(),
900 toOverwrite && aMeshIndex == 0 );
905 toCreateGroups = true;
906 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
909 catch (const SALOME::SALOME_Exception& S_ex){
911 SUIT_MessageBox::warning(SMESHGUI::desktop(),
912 QObject::tr("SMESH_WRN_WARNING"),
913 QObject::tr("SMESH_EXPORT_FAILED"));
919 inline void InverseEntityMode(unsigned int& theOutputMode,
920 unsigned int theMode)
922 bool anIsNotPresent = ~theOutputMode & theMode;
924 theOutputMode |= theMode;
926 theOutputMode &= ~theMode;
929 void SetDisplayEntity(int theCommandID){
930 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
931 SALOME_ListIO selected;
933 aSel->selectedObjects( selected );
935 if(selected.Extent() >= 1){
936 SALOME_ListIteratorOfListIO It( selected );
937 for( ; It.More(); It.Next()){
938 Handle(SALOME_InteractiveObject) IObject = It.Value();
939 if(IObject->hasEntry()){
940 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
941 unsigned int aMode = anActor->GetEntityMode();
942 switch(theCommandID){
943 case SMESHOp::OpDE0DElements:
944 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
946 case SMESHOp::OpDEEdges:
947 InverseEntityMode(aMode,SMESH_Actor::eEdges);
949 case SMESHOp::OpDEFaces:
950 InverseEntityMode(aMode,SMESH_Actor::eFaces);
952 case SMESHOp::OpDEVolumes:
953 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
955 case SMESHOp::OpDEBalls:
956 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
958 case SMESHOp::OpDEAllEntity:
959 aMode = SMESH_Actor::eAllEntity;
963 anActor->SetEntityMode(aMode);
972 SALOME_ListIO selected;
973 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
977 LightApp_SelectionMgr* aSel = app->selectionMgr();
978 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
979 if( !aSel || !appStudy )
982 aSel->selectedObjects( selected );
983 if( selected.IsEmpty() )
986 Handle(SALOME_InteractiveObject) anIObject = selected.First();
988 _PTR(Study) aStudy = appStudy->studyDS();
989 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
990 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
991 if( aMainObject->_is_nil() )
994 SUIT_OverrideCursor wc;
996 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
998 QList<SALOMEDS::Color> aReservedColors;
1000 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1001 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1003 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1004 //SALOMEDS::Color aColor = aGroupObject->GetColor();
1006 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1007 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1008 #else // old algorithm for auto-colors
1009 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1010 aReservedColors.append( aColor );
1011 #endif // SIMPLE_AUTOCOLOR
1012 aGroupObject->SetColor( aColor );
1014 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1015 if (aGroupSObject) {
1018 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1019 switch ( aGroupObject->GetType ()) {
1021 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1023 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1025 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1027 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1029 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1030 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1033 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1034 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1040 SMESH::RepaintCurrentView();
1043 void OverallMeshQuality() {
1044 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1045 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1046 SALOME_ListIO selected;
1048 aSel->selectedObjects( selected );
1050 if ( selected.IsEmpty() ) return;
1051 SALOME_ListIteratorOfListIO It( selected );
1052 for ( ; It.More(); It.Next() ) {
1053 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1054 ctrlDlg->showInfo( It.Value() );
1059 QString functorToString( SMESH::Controls::FunctorPtr f )
1061 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1062 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1063 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1064 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1065 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1066 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1067 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1068 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1069 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1070 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1071 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1072 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1073 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1074 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1075 type = QObject::tr( "WARP_ELEMENTS" );
1076 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1077 type = QObject::tr( "TAPER_ELEMENTS" );
1078 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1079 type = QObject::tr( "SKEW_ELEMENTS" );
1080 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1081 type = QObject::tr( "AREA_ELEMENTS" );
1082 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1083 type = QObject::tr( "LENGTH_EDGES" );
1084 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1085 type = QObject::tr( "LENGTH2D_EDGES" );
1086 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1087 type = QObject::tr( "MULTI_BORDERS" );
1088 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1089 type = QObject::tr( "MULTI2D_BORDERS" );
1090 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1091 type = QObject::tr( "FREE_NODES" );
1092 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1093 type = QObject::tr( "FREE_EDGES" );
1094 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1095 type = QObject::tr( "FREE_BORDERS" );
1096 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1097 type = QObject::tr( "FREE_FACES" );
1098 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1099 type = QObject::tr( "BARE_BORDER_VOLUME" );
1100 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1101 type = QObject::tr( "BARE_BORDER_FACE" );
1102 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1103 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1104 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1105 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1106 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1107 type = QObject::tr( "EQUAL_NODE" );
1108 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1109 type = QObject::tr( "EQUAL_EDGE" );
1110 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1111 type = QObject::tr( "EQUAL_FACE" );
1112 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1113 type = QObject::tr( "EQUAL_VOLUME" );
1117 void SaveDistribution()
1119 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1120 SALOME_ListIO selected;
1122 aSel->selectedObjects( selected );
1124 if ( selected.Extent() == 1 ) {
1125 Handle(SALOME_InteractiveObject) anIO = selected.First();
1126 if ( anIO->hasEntry() ) {
1127 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1128 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1129 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1130 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1131 if ( aScalarBarActor && aFunctor ) {
1132 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1134 std::vector<int> elements;
1135 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1136 if ( mesh->_is_nil() ) {
1137 SMESH::SMESH_IDSource_var idSource =
1138 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1139 if ( !idSource->_is_nil() )
1141 SMESH::long_array_var ids = idSource->GetIDs();
1142 elements.resize( ids->length() );
1143 for ( unsigned i = 0; i < elements.size(); ++i )
1144 elements[i] = ids[i];
1147 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1148 vtkLookupTable* lookupTable =
1149 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1150 double * minmax = lookupTable->GetRange();
1151 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1152 std::vector<int> nbEvents;
1153 std::vector<double> funValues;
1154 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1155 QString anInitialPath = "";
1156 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1157 anInitialPath = QDir::currentPath();
1158 QString aMeshName = anIO->getName();
1160 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1161 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1162 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1163 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1164 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1167 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1169 if ( !aFilename.isEmpty() ) {
1170 QFile f( aFilename );
1171 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1172 QTextStream out( &f );
1173 out << "# Mesh: " << aMeshName << endl;
1174 out << "# Control: " << functorToString( aFunctor ) << endl;
1176 out.setFieldWidth( 10 );
1177 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1178 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1189 void ShowElement(int theCommandID ) {
1190 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1191 SALOME_ListIO selected;
1193 aSel->selectedObjects( selected );
1195 if ( selected.Extent() == 1 ) {
1196 Handle(SALOME_InteractiveObject) anIO = selected.First();
1197 if ( anIO->hasEntry() ) {
1198 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1199 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1200 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1201 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1202 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1204 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1205 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1212 #ifndef DISABLE_PLOT2DVIEWER
1213 void PlotDistribution() {
1214 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1218 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1219 SALOME_ListIO selected;
1221 aSel->selectedObjects( selected );
1223 if ( selected.Extent() == 1 ) {
1224 Handle(SALOME_InteractiveObject) anIO = selected.First();
1225 if ( anIO->hasEntry() ) {
1226 //Find Actor by entry before getting Plot2d viewer,
1227 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1228 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1230 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1235 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1239 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1243 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1244 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1245 QString functorName = functorToString( anActor->GetFunctor());
1246 QString aHistogramName("%1 : %2");
1247 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1248 aHistogram->setName(aHistogramName);
1249 aHistogram->setHorTitle(functorName);
1250 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1251 aPlot->displayObject(aHistogram, true);
1256 #endif //DISABLE_PLOT2DVIEWER
1258 void DisableAutoColor(){
1259 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1260 SALOME_ListIO selected;
1262 aSel->selectedObjects( selected );
1264 if(selected.Extent()){
1265 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1266 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1267 if ( !aMesh->_is_nil() ) {
1268 aMesh->SetAutoColor( false );
1273 void sortChildren(){
1274 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1275 SALOME_ListIO selected;
1277 aSel->selectedObjects( selected );
1279 if(selected.Extent()){
1280 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1281 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1282 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1284 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1285 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1292 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1294 SALOME_ListIO selected;
1295 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1299 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1300 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1301 if( !aSel || !appStudy )
1304 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1305 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1306 aModule->EmitSignalDeactivateDialog();
1307 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1308 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1313 _PTR(Study) aStudy = appStudy->studyDS();
1315 aSel->selectedObjects( selected );
1317 if(selected.Extent() >= 1){
1318 switch(theCommandID){
1319 case SMESHOp::OpTransparency:{
1320 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1321 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1324 case SMESHOp::OpProperties: {
1326 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1327 QColor orientationColor, outlineColor, volumeColor;
1328 int deltaF = 0, deltaV = 0;
1331 double ballScale = 1.0;
1333 int outlineWidth = 1;
1334 double shrinkCoef = 0.0;
1335 double orientationScale = 0.0;
1336 bool orientation3d = false;
1337 VTK::MarkerType markerType = VTK::MT_NONE;
1338 VTK::MarkerScale markerScale = VTK::MS_NONE;
1340 bool hasNodes = false;
1341 int presentEntities = 0;
1342 bool firstTime = true;
1344 SALOME_ListIteratorOfListIO It( selected );
1345 for ( ; It.More(); It.Next() ) {
1346 Handle(SALOME_InteractiveObject) IObject = It.Value();
1347 if ( !IObject->hasEntry() ) continue;
1348 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1349 if ( !anActor || !anActor->GetObject() ) continue;
1352 // nodes: color, marker
1353 anActor->GetNodeColor( color[0], color[1], color[2] );
1354 nodeColor.setRgbF( color[0], color[1], color[2] );
1355 markerType = anActor->GetMarkerType();
1356 markerScale = anActor->GetMarkerScale();
1357 markerId = anActor->GetMarkerTexture();
1358 // edges: color, width
1359 anActor->GetEdgeColor( color[0], color[1], color[2] );
1360 edgeColor.setRgbF( color[0], color[1], color[2] );
1361 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1362 // faces: front color, back color (delta)
1363 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1364 faceColor.setRgbF( color[0], color[1], color[2] );
1365 // faces: front color, back color (delta)
1366 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1367 volumeColor.setRgbF( color[0], color[1], color[2] );
1368 // 0d elements: color, size
1369 anActor->Get0DColor( color[0], color[1], color[2] );
1370 elem0dColor.setRgbF( color[0], color[1], color[2] );
1371 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1372 // balls: color, size
1373 anActor->GetBallColor( color[0], color[1], color[2] );
1374 ballColor.setRgbF( color[0], color[1], color[2] );
1375 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1376 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1378 anActor->GetOutlineColor( color[0], color[1], color[2] );
1379 outlineColor.setRgbF( color[0], color[1], color[2] );
1380 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1381 // orientation vectors: color, scale, 3d flag
1382 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1383 orientationColor.setRgbF( color[0], color[1], color[2] );
1384 orientationScale = anActor->GetFacesOrientationScale();
1385 orientation3d = anActor->GetFacesOrientation3DVectors();
1387 shrinkCoef = anActor->GetShrinkFactor();
1390 firstTime = false; // we only take properties from first object (for performance reasons)
1393 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1394 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1395 presentEntities = presentEntities | SMESH_Actor::eEdges;
1396 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1397 presentEntities = presentEntities | SMESH_Actor::eFaces;
1398 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1399 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1400 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1401 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1402 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1403 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1405 // as we know that all types of elements are present, we can exit the loop
1406 if ( presentEntities == SMESH_Actor::eAllEntity )
1410 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1411 // nodes: color, marker
1412 dlg.setNodeColor( nodeColor );
1413 if( markerType != VTK::MT_USER )
1414 dlg.setNodeMarker( markerType, markerScale );
1416 dlg.setNodeCustomMarker( markerId );
1417 // edges: color, line width
1418 dlg.setEdgeColor( edgeColor );
1419 dlg.setEdgeWidth( edgeWidth );
1420 // faces: front color, back color
1421 dlg.setFaceColor( faceColor, deltaF );
1422 // volumes: normal color, reversed color
1423 dlg.setVolumeColor( volumeColor, deltaV );
1424 // outlines: color, line width
1425 dlg.setOutlineColor( outlineColor );
1426 dlg.setOutlineWidth( outlineWidth );
1427 // 0d elements: color, size
1428 dlg.setElem0dColor( elem0dColor );
1429 dlg.setElem0dSize( elem0dSize );
1430 // balls: color, size
1431 dlg.setBallColor( ballColor );
1432 //dlg.setBallSize( ballSize );
1433 dlg.setBallScale( ballScale );
1434 // orientation: color, scale, 3d flag
1435 dlg.setOrientationColor( orientationColor );
1436 dlg.setOrientationSize( int( orientationScale * 100. ) );
1437 dlg.setOrientation3d( orientation3d );
1438 // shrink: scale factor
1439 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1440 // hide unused controls
1441 dlg.showControls( presentEntities, hasNodes );
1444 nodeColor = dlg.nodeColor();
1445 markerType = dlg.nodeMarkerType();
1446 markerScale = dlg.nodeMarkerScale();
1447 markerId = dlg.nodeMarkerId();
1448 edgeColor = dlg.edgeColor();
1449 edgeWidth = dlg.edgeWidth();
1450 faceColor = dlg.faceColor();
1451 deltaF = dlg.faceColorDelta();
1452 volumeColor = dlg.volumeColor();
1453 deltaV = dlg.volumeColorDelta();
1454 outlineColor = dlg.outlineColor();
1455 outlineWidth = dlg.outlineWidth();
1456 elem0dColor = dlg.elem0dColor();
1457 elem0dSize = dlg.elem0dSize();
1458 ballColor = dlg.ballColor();
1459 // ballSize = dlg.ballSize();
1460 ballScale = dlg.ballScale();
1461 orientationColor = dlg.orientationColor();
1462 orientationScale = dlg.orientationSize() / 100.;
1463 orientation3d = dlg.orientation3d();
1464 shrinkCoef = dlg.shrinkCoef() / 100.;
1466 // store point markers map that might be changed by the user
1467 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1469 // set properties from dialog box to the presentations
1470 SALOME_ListIteratorOfListIO It( selected );
1471 for ( ; It.More(); It.Next() ) {
1472 Handle(SALOME_InteractiveObject) IObject = It.Value();
1473 if ( !IObject->hasEntry() ) continue;
1474 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1475 if ( !anActor ) continue;
1477 // nodes: color, marker
1478 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1479 if ( markerType != VTK::MT_USER ) {
1480 anActor->SetMarkerStd( markerType, markerScale );
1483 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1484 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1485 if ( iter != markerMap.end() )
1486 anActor->SetMarkerTexture( markerId, iter->second.second );
1488 // volumes: normal color, reversed color (delta)
1489 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1490 // faces: front color, back color (delta)
1491 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1492 // edges: color, width
1493 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1494 anActor->SetLineWidth( edgeWidth );
1496 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1497 anActor->SetOutlineWidth( outlineWidth );
1498 // 0D elements: color, size
1499 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1500 anActor->Set0DSize( elem0dSize );
1501 // balls: color, size
1502 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1503 // anActor->SetBallSize( ballSize );
1504 anActor->SetBallScale( ballScale );
1505 // orientation: color, scale, 3d flag
1506 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1507 anActor->SetFacesOrientationScale( orientationScale );
1508 anActor->SetFacesOrientation3DVectors( orientation3d );
1510 anActor->SetShrinkFactor( shrinkCoef );
1512 // for groups, set also proper color
1513 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1514 if ( !aGroupObject->_is_nil() ) {
1515 SMESH::ElementType anElementType = aGroupObject->GetType();
1517 switch( anElementType ) {
1519 aColor = nodeColor; break;
1521 aColor = edgeColor; break;
1523 aColor = faceColor; break;
1525 aColor = volumeColor; break;
1527 aColor = elem0dColor; break;
1529 aColor = ballColor; break;
1533 if ( aColor.isValid() ) {
1534 SALOMEDS::Color aGroupColor;
1535 aGroupColor.R = aColor.redF();
1536 aGroupColor.G = aColor.greenF();
1537 aGroupColor.B = aColor.blueF();
1538 aGroupObject->SetColor( aGroupColor );
1540 } // if ( !aGroupObject->_is_nil() )
1541 } // for ( ; It.More(); It.Next() )
1542 SMESH::RepaintCurrentView();
1543 } // if ( dlg.exec() )
1545 } // case SMESHOp::OpProperties:
1546 } // switch(theCommandID)
1547 SALOME_ListIteratorOfListIO It( selected );
1548 for( ; It.More(); It.Next()){
1549 Handle(SALOME_InteractiveObject) IObject = It.Value();
1550 if(IObject->hasEntry()){
1551 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1552 switch(theCommandID){
1553 case SMESHOp::OpDMWireframe:
1554 anActor->SetRepresentation(SMESH_Actor::eEdge);
1556 case SMESHOp::OpDMShading:
1557 anActor->SetRepresentation(SMESH_Actor::eSurface);
1559 case SMESHOp::OpDMShrink:
1560 if(anActor->IsShrunk())
1561 anActor->UnShrink();
1563 anActor->SetShrink();
1565 case SMESHOp::OpDMNodes:
1566 anActor->SetRepresentation(SMESH_Actor::ePoint);
1568 case SMESHOp::OpRepresentationLines:
1569 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1570 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1572 case SMESHOp::OpRepresentationArcs:
1573 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1574 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1580 SMESH::RepaintCurrentView();
1584 void Control( int theCommandID )
1586 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1587 switch ( theCommandID ){
1588 case SMESHOp::OpFreeNode:
1589 aControl = SMESH_Actor::eFreeNodes;
1591 case SMESHOp::OpEqualNode:
1592 aControl = SMESH_Actor::eCoincidentNodes;
1594 case SMESHOp::OpFreeEdge:
1595 aControl = SMESH_Actor::eFreeEdges;
1597 case SMESHOp::OpFreeBorder:
1598 aControl = SMESH_Actor::eFreeBorders;
1600 case SMESHOp::OpLength:
1601 aControl = SMESH_Actor::eLength;
1603 case SMESHOp::OpConnection:
1604 aControl = SMESH_Actor::eMultiConnection;
1606 case SMESHOp::OpEqualEdge:
1607 aControl = SMESH_Actor::eCoincidentElems1D;
1609 case SMESHOp::OpFreeFace:
1610 aControl = SMESH_Actor::eFreeFaces;
1612 case SMESHOp::OpBareBorderFace:
1613 aControl = SMESH_Actor::eBareBorderFace;
1615 case SMESHOp::OpOverConstrainedFace:
1616 aControl = SMESH_Actor::eOverConstrainedFace;
1618 case SMESHOp::OpLength2D:
1619 aControl = SMESH_Actor::eLength2D;
1621 case SMESHOp::OpConnection2D:
1622 aControl = SMESH_Actor::eMultiConnection2D;
1624 case SMESHOp::OpArea:
1625 aControl = SMESH_Actor::eArea;
1627 case SMESHOp::OpTaper:
1628 aControl = SMESH_Actor::eTaper;
1630 case SMESHOp::OpAspectRatio:
1631 aControl = SMESH_Actor::eAspectRatio;
1633 case SMESHOp::OpMinimumAngle:
1634 aControl = SMESH_Actor::eMinimumAngle;
1636 case SMESHOp::OpWarpingAngle:
1637 aControl = SMESH_Actor::eWarping;
1639 case SMESHOp::OpSkew:
1640 aControl = SMESH_Actor::eSkew;
1642 case SMESHOp::OpMaxElementLength2D:
1643 aControl = SMESH_Actor::eMaxElementLength2D;
1645 case SMESHOp::OpEqualFace:
1646 aControl = SMESH_Actor:: eCoincidentElems2D;
1648 case SMESHOp::OpAspectRatio3D:
1649 aControl = SMESH_Actor::eAspectRatio3D;
1651 case SMESHOp::OpVolume:
1652 aControl = SMESH_Actor::eVolume3D;
1654 case SMESHOp::OpMaxElementLength3D:
1655 aControl = SMESH_Actor::eMaxElementLength3D;
1657 case SMESHOp::OpBareBorderVolume:
1658 aControl = SMESH_Actor::eBareBorderVolume;
1660 case SMESHOp::OpOverConstrainedVolume:
1661 aControl = SMESH_Actor::eOverConstrainedVolume;
1663 case SMESHOp::OpEqualVolume:
1664 aControl = SMESH_Actor::eCoincidentElems3D;
1667 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1668 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1669 SALOME_ListIO selected;
1671 aSel->selectedObjects( selected );
1673 if( !selected.IsEmpty() ){
1674 SALOME_ListIteratorOfListIO It(selected);
1675 for ( ; It.More(); It.Next())
1677 Handle(SALOME_InteractiveObject) anIO = It.Value();
1679 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1681 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1682 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1683 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1684 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1685 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1686 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1687 anActor->SetControlMode(aControl);
1688 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1689 SMESH::RepaintCurrentView();
1690 #ifndef DISABLE_PLOT2DVIEWER
1691 if(anActor->GetPlot2Histogram()) {
1692 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1693 QString functorName = functorToString( anActor->GetFunctor());
1694 QString aHistogramName("%1 : %2");
1695 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1696 aHistogram->setName(aHistogramName);
1697 aHistogram->setHorTitle(functorName);
1698 SMESH::ProcessIn2DViewers(anActor);
1710 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1711 SMESH::MeshObjectType theType,
1712 const QString theInTypeName,
1713 QString & theOutTypeName)
1715 SMESH_TypeFilter aTypeFilter( theType );
1717 if( !theIO.IsNull() )
1719 entry = theIO->getEntry();
1720 LightApp_DataOwner owner( entry );
1721 if ( aTypeFilter.isOk( &owner )) {
1722 theOutTypeName = theInTypeName;
1730 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1732 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1733 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1735 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1736 CORBA::String_var anID = aSComp->GetID().c_str();
1737 if (!strcmp(anID.in(),theIO->getEntry()))
1743 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1744 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1745 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1746 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1747 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1755 QString CheckHomogeneousSelection()
1757 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1758 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1759 SALOME_ListIO selected;
1761 aSel->selectedObjects( selected );
1763 QString RefType = CheckTypeObject(selected.First());
1764 SALOME_ListIteratorOfListIO It(selected);
1765 for ( ; It.More(); It.Next())
1767 Handle(SALOME_InteractiveObject) IObject = It.Value();
1768 QString Type = CheckTypeObject(IObject);
1769 if (Type.compare(RefType) != 0)
1770 return "Heterogeneous Selection";
1776 uint randomize( uint size )
1778 static bool initialized = false;
1779 if ( !initialized ) {
1780 qsrand( QDateTime::currentDateTime().toTime_t() );
1784 v = uint( (double)( v ) / RAND_MAX * size );
1785 v = qMax( uint(0), qMin ( v, size-1 ) );
1791 void SMESHGUI::OnEditDelete()
1793 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1794 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1795 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1797 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1798 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1799 _PTR(GenericAttribute) anAttr;
1800 _PTR(AttributeIOR) anIOR;
1802 int objectCount = 0;
1804 QString aParentComponent = QString::null;
1805 Handle(SALOME_InteractiveObject) anIO;
1806 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1808 anIO = anIt.Value();
1809 QString cur = anIO->getComponentDataType();
1810 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1812 // check if object is reference
1813 _PTR(SObject) aRefSObj;
1814 aNameList.append("\n - ");
1815 if ( aSO->ReferencedObject( aRefSObj ) ) {
1816 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1817 aNameList.append( aRefName );
1818 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1821 aNameList.append(anIO->getName());
1825 if( aParentComponent.isNull() )
1826 aParentComponent = cur;
1827 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1828 aParentComponent = "";
1831 if ( objectCount == 0 )
1832 return; // No Valid Objects Selected
1834 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1835 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1836 QObject::tr("ERR_ERROR"),
1837 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1840 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1841 if (SUIT_MessageBox::warning
1842 (SMESHGUI::desktop(),
1843 QObject::tr("SMESH_WRN_WARNING"),
1844 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1845 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1846 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1849 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1851 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1852 // then treat them all starting from the deepest objects (at list back)
1853 std::list< _PTR(SObject) > listSO;
1854 SALOME_ListIteratorOfListIO It(selected);
1855 for( ; It.More(); It.Next()) // loop on selected IO's
1857 Handle(SALOME_InteractiveObject) IObject = It.Value();
1858 if(IObject->hasEntry()) {
1859 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1861 // disable removal of "SMESH" component object
1862 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1864 if ( engineIOR() == anIOR->Value().c_str() )
1867 //Check the referenced object
1868 _PTR(SObject) aRefSObject;
1869 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1870 aSO = aRefSObject; // Delete main Object instead of reference
1872 listSO.push_back( aSO );
1873 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1874 for ( ; itSO != listSO.end(); ++itSO ) {
1875 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1876 for (it->InitEx(false); it->More(); it->Next())
1877 listSO.push_back( it->Value() );
1881 // Check if none of objects to delete is referred from outside
1882 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1883 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1885 _PTR(SObject) SO = *ritSO;
1886 if ( !SO ) continue;
1887 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1888 for (size_t i = 0; i < aReferences.size(); i++) {
1889 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1890 std::string type = aComponent->ComponentDataType();
1891 if ( type != "SMESH" )
1893 SUIT_MessageBox::warning( anApp->desktop(),
1894 QObject::tr("WRN_WARNING"),
1895 QObject::tr("DEP_OBJECT") );
1896 return; // outside SMESH, there is an object depending on a SMESH object
1901 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1902 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1904 Handle(SALOME_InteractiveObject) IObject = It.Value();
1905 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1906 if ( !mesh->_is_nil() )
1910 // Treat SO's in the list starting from the back
1911 aStudyBuilder->NewCommand(); // There is a transaction
1912 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1914 _PTR(SObject) SO = *ritSO;
1915 if ( !SO ) continue;
1916 std::string anEntry = SO->GetID();
1918 /** Erase graphical object and remove all its data **/
1919 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1920 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1922 /** Remove an object from data structures **/
1923 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1924 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1925 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1926 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1927 aMesh->RemoveGroup( aGroup );
1929 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1930 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1931 aMesh->RemoveSubMesh( aSubMesh );
1933 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1935 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1938 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1939 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1940 QString objType = CheckTypeObject(IObject);
1941 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1942 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1943 aStudyBuilder->RemoveObjectWithChildren( SO );
1945 else {// default action: remove SObject from the study
1946 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1947 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1949 aStudyBuilder->RemoveObjectWithChildren( SO );
1953 } /* listSO back loop */
1955 aStudyBuilder->CommitCommand();
1957 /* Clear any previous selection */
1959 aSel->setSelectedObjects( l1 );
1961 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1965 SMESHGUI_EXPORT CAM_Module* createModule()
1967 return new SMESHGUI();
1970 SMESHGUI_EXPORT char* getModuleVersion() {
1971 return (char*)SMESH_VERSION_STR;
1975 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1977 //=============================================================================
1981 //=============================================================================
1982 SMESHGUI::SMESHGUI() :
1983 SalomeApp_Module( "SMESH" )
1985 if ( CORBA::is_nil( myComponentSMESH ) )
1987 CORBA::Boolean anIsEmbeddedMode;
1988 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1989 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1991 // 0019923: EDF 765 SMESH : default values of hypothesis
1992 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1993 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1994 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1995 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1996 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1998 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1999 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2000 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2002 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2003 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2007 myActiveDialogBox = 0;
2008 myFilterLibraryDlg = 0;
2012 myEventCallbackCommand = vtkCallbackCommand::New();
2013 myEventCallbackCommand->Delete();
2014 myEventCallbackCommand->SetClientData( this );
2015 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2018 /* load resources for all available meshers */
2019 SMESH::InitAvailableHypotheses();
2022 //=============================================================================
2026 //=============================================================================
2027 SMESHGUI::~SMESHGUI()
2031 //=============================================================================
2035 //=============================================================================
2036 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2038 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2040 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2045 //=============================================================================
2049 //=============================================================================
2050 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2052 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2056 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2057 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2058 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2059 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2060 return autoUpdate && !exceeded;
2063 //=============================================================================
2067 //=============================================================================
2068 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2069 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2071 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2075 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2076 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2077 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2079 SMESH::long_array_var info = theMesh->GetMeshInfo();
2080 long nbOdElems = info[SMDSEntity_0D];
2081 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2082 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2083 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2084 info[SMDSEntity_Polygon];
2085 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2086 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2087 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2088 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2089 info[SMDSEntity_Polyhedra] +
2090 info[SMDSEntity_Hexagonal_Prism];
2091 long nbBalls = info[SMDSEntity_Ball];
2093 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2094 *nbElements = requestedSize;
2096 *entities = SMESH_Actor::eAllEntity;
2099 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2101 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2103 if ( incrementalLimit ) {
2106 if ( nbOdElems > 0 ) {
2107 if ( total + nbOdElems > updateLimit ) {
2108 *entities = *entities & ~SMESH_Actor::e0DElements;
2109 *hidden = *hidden | SMESH_Actor::e0DElements;
2116 if ( nbEdges > 0 ) {
2117 if ( total + nbEdges > updateLimit ) {
2118 *entities = *entities & ~SMESH_Actor::eEdges;
2119 *hidden = *hidden | SMESH_Actor::eEdges;
2126 if ( nbFaces > 0 ) {
2127 if ( total + nbFaces > updateLimit ) {
2128 *entities = *entities & ~SMESH_Actor::eFaces;
2129 *hidden = *hidden | SMESH_Actor::eFaces;
2136 if ( nbVolumes > 0 ) {
2137 if ( total + nbVolumes > updateLimit ) {
2138 *entities = *entities & ~SMESH_Actor::eVolumes;
2139 *hidden = *hidden | SMESH_Actor::eVolumes;
2146 if ( nbBalls > 0 ) {
2147 if ( total + nbBalls > updateLimit ) {
2148 *entities = *entities & ~SMESH_Actor::eBallElem;
2149 *hidden = *hidden | SMESH_Actor::eBallElem;
2157 return autoUpdate && !exceeded;
2160 //=============================================================================
2164 //=============================================================================
2165 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2167 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2170 //=============================================================================
2174 //=============================================================================
2175 SMESHGUI* SMESHGUI::GetSMESHGUI()
2177 SMESHGUI* smeshMod = 0;
2178 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2181 CAM_Module* module = app->module( "Mesh" );
2182 smeshMod = dynamic_cast<SMESHGUI*>( module );
2185 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2187 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2190 _PTR(Study) aStudy = study->studyDS();
2192 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2201 Standard_EXPORT SMESHGUI* GetComponentGUI()
2203 return SMESHGUI::GetSMESHGUI();
2207 //=============================================================================
2211 //=============================================================================
2212 void SMESHGUI::SetState(int aState)
2217 //=============================================================================
2221 //=============================================================================
2222 void SMESHGUI::ResetState()
2227 //=============================================================================
2231 //=============================================================================
2232 void SMESHGUI::EmitSignalDeactivateDialog()
2234 emit SignalDeactivateActiveDialog();
2237 //=============================================================================
2241 //=============================================================================
2242 void SMESHGUI::EmitSignalStudyFrameChanged()
2244 emit SignalStudyFrameChanged();
2247 //=============================================================================
2251 //=============================================================================
2252 void SMESHGUI::EmitSignalCloseAllDialogs()
2254 emit SignalCloseAllDialogs();
2257 //=============================================================================
2261 //=============================================================================
2262 void SMESHGUI::EmitSignalVisibilityChanged()
2264 emit SignalVisibilityChanged();
2267 //=============================================================================
2271 //=============================================================================
2272 QDialog *SMESHGUI::GetActiveDialogBox()
2274 return myActiveDialogBox;
2277 //=============================================================================
2281 //=============================================================================
2282 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2284 myActiveDialogBox = (QDialog *) aDlg;
2288 //=============================================================================
2292 //=============================================================================
2293 SUIT_Desktop* SMESHGUI::desktop()
2295 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2297 return app->desktop();
2302 //=============================================================================
2306 //=============================================================================
2307 SalomeApp_Study* SMESHGUI::activeStudy()
2309 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2311 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2316 //=============================================================================
2320 //=============================================================================
2321 void SMESHGUI::Modified( bool theIsUpdateActions )
2323 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2324 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2325 appStudy->Modified();
2326 if( theIsUpdateActions )
2327 app->updateActions();
2332 //=============================================================================
2336 //=============================================================================
2337 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2339 /* Here the position is on the bottom right corner - 10 */
2340 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2342 SUIT_Desktop *PP = desktop();
2343 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2344 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2348 //=============================================================================
2352 //=============================================================================
2353 static int isStudyLocked(_PTR(Study) theStudy){
2354 return theStudy->GetProperties()->IsLocked();
2357 static bool checkLock(_PTR(Study) theStudy) {
2358 if (isStudyLocked(theStudy)) {
2359 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2360 QObject::tr("WRN_WARNING"),
2361 QObject::tr("WRN_STUDY_LOCKED") );
2367 //=======================================================================
2368 //function : CheckActiveStudyLocked
2370 //=======================================================================
2372 bool SMESHGUI::isActiveStudyLocked()
2374 _PTR(Study) aStudy = activeStudy()->studyDS();
2375 return checkLock( aStudy );
2378 //=============================================================================
2382 //=============================================================================
2383 bool SMESHGUI::OnGUIEvent( int theCommandID )
2385 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2389 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2390 SUIT_ResourceMgr* mgr = resourceMgr();
2394 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2395 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2398 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2399 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2401 //QAction* act = action( theCommandID );
2403 switch (theCommandID) {
2404 case SMESHOp::OpDelete:
2405 if(checkLock(aStudy)) break;
2408 case SMESHOp::OpImportDAT:
2409 case SMESHOp::OpImportUNV:
2410 case SMESHOp::OpImportMED:
2411 case SMESHOp::OpImportSTL:
2413 case SMESHOp::OpImportCGNS:
2415 case SMESHOp::OpImportSAUV:
2416 case SMESHOp::OpImportGMF:
2418 if(checkLock(aStudy)) break;
2419 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2423 case SMESHOp::OpFileInformation:
2425 SALOME_ListIO selected;
2426 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2428 aSel->selectedObjects( selected );
2429 if( selected.Extent() )
2431 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2432 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2433 if ( !aMesh->_is_nil() )
2435 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2441 case SMESHOp::OpExportDAT:
2442 case SMESHOp::OpExportMED:
2443 case SMESHOp::OpExportUNV:
2444 case SMESHOp::OpExportSTL:
2446 case SMESHOp::OpExportCGNS:
2448 case SMESHOp::OpExportSAUV:
2449 case SMESHOp::OpExportGMF:
2450 case SMESHOp::OpPopupExportDAT:
2451 case SMESHOp::OpPopupExportMED:
2452 case SMESHOp::OpPopupExportUNV:
2453 case SMESHOp::OpPopupExportSTL:
2455 case SMESHOp::OpPopupExportCGNS:
2457 case SMESHOp::OpPopupExportSAUV:
2458 case SMESHOp::OpPopupExportGMF:
2460 ::ExportMeshToFile(theCommandID);
2464 case SMESHOp::OpReset: // SCALAR BAR
2466 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2467 SALOME_ListIO selected;
2469 aSel->selectedObjects( selected );
2471 if( selected.Extent() ) {
2472 Handle(SALOME_InteractiveObject) anIO = selected.First();
2473 if( anIO->hasEntry() ) {
2474 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2475 anActor->SetControlMode( SMESH_Actor::eNone );
2476 #ifndef DISABLE_PLOT2DVIEWER
2477 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2484 case SMESHOp::OpScalarBarProperties:
2486 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2489 case SMESHOp::OpShowScalarBar:
2491 // show/hide scalar bar
2492 ::ShowElement(theCommandID);
2495 case SMESHOp::OpSaveDistribution:
2497 // dump control distribution data to the text file
2498 ::SaveDistribution();
2502 case SMESHOp::OpShowDistribution:
2504 // show/hide distribution
2505 ::ShowElement(theCommandID);
2509 #ifndef DISABLE_PLOT2DVIEWER
2510 case SMESHOp::OpPlotDistribution:
2512 // plot distribution
2513 ::PlotDistribution();
2519 case SMESHOp::OpAutoColor:
2523 case SMESHOp::OpDisableAutoColor:
2524 ::DisableAutoColor();
2527 case SMESHOp::OpClipping:
2528 case SMESHOp::OpTransparency:
2529 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2532 case SMESHOp::OpDMWireframe:
2533 case SMESHOp::OpDMShading:
2534 case SMESHOp::OpDMNodes:
2535 case SMESHOp::OpDMShrink:
2536 ::SetDisplayMode(theCommandID, myMarkerMap);
2539 //2D quadratic representation
2540 case SMESHOp::OpRepresentationLines:
2541 case SMESHOp::OpRepresentationArcs:
2542 ::SetDisplayMode(theCommandID, myMarkerMap);
2546 case SMESHOp::OpDE0DElements:
2547 case SMESHOp::OpDEEdges:
2548 case SMESHOp::OpDEFaces:
2549 case SMESHOp::OpDEVolumes:
2550 case SMESHOp::OpDEBalls:
2551 case SMESHOp::OpDEAllEntity:
2552 ::SetDisplayEntity(theCommandID);
2555 // Choose entities to be displayed
2556 case SMESHOp::OpDEChoose:
2558 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2562 case SMESHOp::OpOrientationOnFaces:
2564 LightApp_SelectionMgr* mgr = selectionMgr();
2565 SALOME_ListIO selected; mgr->selectedObjects( selected );
2567 SALOME_ListIteratorOfListIO it(selected);
2568 for( ; it.More(); it.Next()) {
2569 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2570 if(anIObject->hasEntry()) {
2571 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2572 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2579 case SMESHOp::OpUpdate:
2581 if(checkLock(aStudy)) break;
2582 SUIT_OverrideCursor wc;
2584 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2587 SMESH::UpdateView();
2589 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2590 SMESH::OnVisuException();
2592 catch (...) { // PAL16774 (Crash after display of many groups)
2593 SMESH::OnVisuException();
2597 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2598 aSel->selectedObjects( l );
2599 aSel->setSelectedObjects( l );
2603 case SMESHOp::OpHide:
2604 case SMESHOp::OpShow:
2605 case SMESHOp::OpShowOnly:
2607 SMESH::EDisplaing anAction;
2608 switch (theCommandID) {
2609 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2610 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2611 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2614 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2615 SALOME_ListIO sel_objects, to_process;
2617 aSel->selectedObjects( sel_objects );
2619 if( theCommandID==SMESHOp::OpShowOnly )
2621 MESSAGE("anAction = SMESH::eDisplayOnly");
2622 startOperation( myEraseAll );
2625 extractContainers( sel_objects, to_process );
2628 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2632 SALOME_ListIteratorOfListIO It( to_process );
2633 for ( ; It.More(); It.Next()) {
2635 Handle(SALOME_InteractiveObject) IOS = It.Value();
2636 if (IOS->hasEntry()) {
2638 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2639 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2640 break; // PAL16774 (Crash after display of many groups)
2642 if (anAction == SMESH::eDisplayOnly)
2644 MESSAGE("anAction = SMESH::eDisplayOnly");
2645 anAction = SMESH::eDisplay;
2651 // PAL13338 + PAL15161 -->
2652 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2653 MESSAGE("anAction = SMESH::eDisplayOnly");
2654 SMESH::UpdateView();
2655 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2657 // PAL13338 + PAL15161 <--
2659 catch (...) { // PAL16774 (Crash after display of many groups)
2660 SMESH::OnVisuException();
2663 if (anAction == SMESH::eErase) {
2664 MESSAGE("anAction == SMESH::eErase");
2666 aSel->setSelectedObjects( l1 );
2669 aSel->setSelectedObjects( to_process );
2674 case SMESHOp::OpNode:
2676 if(checkLock(aStudy)) break;
2679 EmitSignalDeactivateDialog();
2681 ( new SMESHGUI_NodesDlg( this ) )->show();
2684 SUIT_MessageBox::warning(desktop(),
2685 tr("SMESH_WRN_WARNING"),
2686 tr("SMESH_WRN_VIEWER_VTK"));
2691 case SMESHOp::OpCreateMesh:
2692 case SMESHOp::OpCreateSubMesh:
2693 case SMESHOp::OpEditMeshOrSubMesh:
2694 case SMESHOp::OpCompute:
2695 case SMESHOp::OpPreCompute:
2696 case SMESHOp::OpEvaluate:
2697 case SMESHOp::OpMeshOrder:
2698 startOperation( theCommandID );
2700 case SMESHOp::OpCopyMesh:
2702 if (checkLock(aStudy)) break;
2703 EmitSignalDeactivateDialog();
2704 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2707 case SMESHOp::OpBuildCompoundMesh:
2709 if (checkLock(aStudy)) break;
2710 EmitSignalDeactivateDialog();
2711 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2715 case SMESHOp::OpDiagonalInversion:
2716 case SMESHOp::OpUnionOfTwoTriangle:
2720 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2721 tr( "NOT_A_VTK_VIEWER" ) );
2725 if ( checkLock( aStudy ) )
2728 /*Standard_Boolean aRes;
2729 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2730 if ( aMesh->_is_nil() )
2732 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2733 tr( "SMESH_BAD_SELECTION" ) );
2737 EmitSignalDeactivateDialog();
2738 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2739 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2741 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2744 case SMESHOp::OpOrientation:
2745 case SMESHOp::OpUnionOfTriangles:
2746 case SMESHOp::OpCuttingOfQuadrangles:
2747 case SMESHOp::OpSplitVolumes:
2751 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2752 tr( "NOT_A_VTK_VIEWER" ) );
2756 if ( checkLock( aStudy ) )
2759 EmitSignalDeactivateDialog();
2760 SMESHGUI_MultiEditDlg* aDlg = NULL;
2761 if ( theCommandID == SMESHOp::OpOrientation )
2762 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2763 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2764 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2765 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2766 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2768 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2773 case SMESHOp::OpSmoothing:
2775 if(checkLock(aStudy)) break;
2777 EmitSignalDeactivateDialog();
2778 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2781 SUIT_MessageBox::warning(desktop(),
2782 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2786 case SMESHOp::OpExtrusion:
2788 if (checkLock(aStudy)) break;
2790 EmitSignalDeactivateDialog();
2791 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2793 SUIT_MessageBox::warning(desktop(),
2794 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2798 case SMESHOp::OpExtrusionAlongAPath:
2800 if (checkLock(aStudy)) break;
2802 EmitSignalDeactivateDialog();
2803 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2805 SUIT_MessageBox::warning(desktop(),
2806 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2810 case SMESHOp::OpRevolution:
2812 if(checkLock(aStudy)) break;
2814 EmitSignalDeactivateDialog();
2815 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2818 SUIT_MessageBox::warning(desktop(),
2819 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2823 case SMESHOp::OpPatternMapping:
2825 if ( checkLock( aStudy ) )
2829 EmitSignalDeactivateDialog();
2830 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2833 SUIT_MessageBox::warning(desktop(),
2834 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2838 case SMESHOp::OpConvertMeshToQuadratic:
2839 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2840 case SMESHOp::OpReorientFaces:
2841 case SMESHOp::OpCreateGeometryGroup:
2843 startOperation( theCommandID );
2846 case SMESHOp::OpCreateGroup:
2850 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2851 tr( "NOT_A_VTK_VIEWER" ) );
2855 if(checkLock(aStudy)) break;
2856 EmitSignalDeactivateDialog();
2857 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2859 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2860 SALOME_ListIO selected;
2862 aSel->selectedObjects( selected );
2864 int nbSel = selected.Extent();
2866 // check if mesh is selected
2867 aMesh = SMESH::GetMeshByIO( selected.First() );
2869 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2874 case SMESHOp::OpConstructGroup:
2878 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2879 tr( "NOT_A_VTK_VIEWER" ) );
2883 if(checkLock(aStudy)) break;
2884 EmitSignalDeactivateDialog();
2886 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2887 SALOME_ListIO selected;
2889 aSel->selectedObjects( selected );
2891 int nbSel = selected.Extent();
2893 // check if submesh is selected
2894 Handle(SALOME_InteractiveObject) IObject = selected.First();
2895 if (IObject->hasEntry()) {
2896 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2898 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2899 if (!aSubMesh->_is_nil()) {
2901 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2902 // get submesh elements list by types
2903 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2904 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2905 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2906 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2907 // create group for each type o elements
2908 QString aName = IObject->getName();
2909 QStringList anEntryList;
2910 if (aNodes->length() > 0) {
2911 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2912 aGroup->Add(aNodes.inout());
2913 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2914 anEntryList.append( aSObject->GetID().c_str() );
2916 if (aEdges->length() > 0) {
2917 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2918 aGroup->Add(aEdges.inout());
2919 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2920 anEntryList.append( aSObject->GetID().c_str() );
2922 if (aFaces->length() > 0) {
2923 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2924 aGroup->Add(aFaces.inout());
2925 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2926 anEntryList.append( aSObject->GetID().c_str() );
2928 if (aVolumes->length() > 0) {
2929 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2930 aGroup->Add(aVolumes.inout());
2931 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2932 anEntryList.append( aSObject->GetID().c_str() );
2935 anApp->browseObjects( anEntryList );
2937 catch(const SALOME::SALOME_Exception & S_ex){
2938 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2945 SUIT_MessageBox::warning(desktop(),
2946 tr("SMESH_WRN_WARNING"),
2947 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2952 case SMESHOp::OpEditGroup:
2956 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2957 tr( "NOT_A_VTK_VIEWER" ) );
2961 if(checkLock(aStudy)) break;
2962 EmitSignalDeactivateDialog();
2964 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2965 SALOME_ListIO selected;
2967 aSel->selectedObjects( selected );
2969 SALOME_ListIteratorOfListIO It (selected);
2970 int nbSelectedGroups = 0;
2971 for ( ; It.More(); It.Next() )
2973 SMESH::SMESH_GroupBase_var aGroup =
2974 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2975 if (!aGroup->_is_nil()) {
2977 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2981 if (nbSelectedGroups == 0)
2983 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2989 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2991 if(checkLock(aStudy)) break;
2992 if (myState == 800) {
2993 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2994 if (aDlg) aDlg->onAdd();
2999 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3001 if(checkLock(aStudy)) break;
3002 if (myState == 800) {
3003 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3004 if (aDlg) aDlg->onRemove();
3009 case SMESHOp::OpEditGeomGroupAsGroup:
3013 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3014 tr( "NOT_A_VTK_VIEWER" ) );
3018 if(checkLock(aStudy)) break;
3019 EmitSignalDeactivateDialog();
3021 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3022 SALOME_ListIO selected;
3024 aSel->selectedObjects( selected );
3026 SALOME_ListIteratorOfListIO It (selected);
3027 for ( ; It.More(); It.Next() )
3029 SMESH::SMESH_GroupOnGeom_var aGroup =
3030 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3031 if (!aGroup->_is_nil()) {
3032 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3037 SMESH::SMESH_GroupOnFilter_var aGroup =
3038 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3039 if (!aGroup->_is_nil()) {
3040 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3048 case SMESHOp::OpUnionGroups:
3049 case SMESHOp::OpIntersectGroups:
3050 case SMESHOp::OpCutGroups:
3054 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3055 tr( "NOT_A_VTK_VIEWER" ) );
3059 if ( checkLock( aStudy ) )
3062 EmitSignalDeactivateDialog();
3064 SMESHGUI_GroupOpDlg* aDlg = 0;
3065 if ( theCommandID == SMESHOp::OpUnionGroups )
3066 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3067 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3068 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3070 aDlg = new SMESHGUI_CutGroupsDlg( this );
3077 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3079 if ( checkLock( aStudy ) )
3082 EmitSignalDeactivateDialog();
3083 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3089 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3093 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3094 tr( "NOT_A_VTK_VIEWER" ) );
3098 if ( checkLock( aStudy ) )
3101 EmitSignalDeactivateDialog();
3103 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3107 case SMESHOp::OpMeshInformation:
3108 case SMESHOp::OpWhatIs:
3110 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3111 EmitSignalDeactivateDialog();
3112 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3113 SALOME_ListIO selected;
3115 aSel->selectedObjects( selected );
3117 if ( selected.Extent() > 1 ) { // a dlg for each IO
3118 SALOME_ListIteratorOfListIO It( selected );
3119 for ( ; It.More(); It.Next() ) {
3120 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3121 dlg->showInfo( It.Value() );
3126 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3132 case SMESHOp::OpFindElementByPoint:
3134 startOperation( theCommandID );
3138 case SMESHOp::OpEditHypothesis:
3140 if(checkLock(aStudy)) break;
3142 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3143 SALOME_ListIO selected;
3145 aSel->selectedObjects( selected );
3147 int nbSel = selected.Extent();
3150 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3151 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3153 if ( !aHypothesis->_is_nil() )
3155 SMESHGUI_GenericHypothesisCreator* aCreator =
3156 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3159 // set geometry of mesh and sub-mesh to aCreator
3160 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3161 if ( selected.Extent() == 1 )
3163 QString subGeomID, meshGeomID;
3164 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3165 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3167 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3168 aCreator->setShapeEntry( subGeomID );
3169 aCreator->setMainShapeEntry( meshGeomID );
3173 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3183 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3185 if(checkLock(aStudy)) break;
3186 SUIT_OverrideCursor wc;
3188 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3189 SALOME_ListIO selected;
3191 aSel->selectedObjects( selected, QString::null, false );
3193 SALOME_ListIteratorOfListIO It(selected);
3194 for (int i = 0; It.More(); It.Next(), i++) {
3195 Handle(SALOME_InteractiveObject) IObject = It.Value();
3196 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3199 aSel->setSelectedObjects( l1 );
3204 case SMESHOp::OpElem0D:
3205 case SMESHOp::OpBall:
3206 case SMESHOp::OpEdge:
3207 case SMESHOp::OpTriangle:
3208 case SMESHOp::OpQuadrangle:
3209 case SMESHOp::OpPolygon:
3210 case SMESHOp::OpTetrahedron:
3211 case SMESHOp::OpHexahedron:
3212 case SMESHOp::OpPentahedron:
3213 case SMESHOp::OpPyramid:
3214 case SMESHOp::OpHexagonalPrism:
3216 if(checkLock(aStudy)) break;
3218 EmitSignalDeactivateDialog();
3219 SMDSAbs_EntityType type = SMDSEntity_Edge;
3220 switch (theCommandID) {
3221 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3222 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3223 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3224 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3225 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3226 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3227 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3228 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3229 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3230 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3233 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3236 SUIT_MessageBox::warning(desktop(),
3237 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3241 case SMESHOp::OpPolyhedron:
3243 if(checkLock(aStudy)) break;
3245 EmitSignalDeactivateDialog();
3246 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3249 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3250 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3254 case SMESHOp::OpQuadraticEdge:
3255 case SMESHOp::OpQuadraticTriangle:
3256 case SMESHOp::OpBiQuadraticTriangle:
3257 case SMESHOp::OpQuadraticQuadrangle:
3258 case SMESHOp::OpBiQuadraticQuadrangle:
3259 case SMESHOp::OpQuadraticTetrahedron:
3260 case SMESHOp::OpQuadraticPyramid:
3261 case SMESHOp::OpQuadraticPentahedron:
3262 case SMESHOp::OpQuadraticHexahedron:
3263 case SMESHOp::OpTriQuadraticHexahedron:
3265 if(checkLock(aStudy)) break;
3267 EmitSignalDeactivateDialog();
3268 SMDSAbs_EntityType type = SMDSEntity_Last;
3270 switch (theCommandID) {
3271 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3272 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3273 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3274 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3275 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3276 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3277 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3278 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3279 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3280 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3283 if ( type != SMDSEntity_Last )
3284 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3287 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3288 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3292 case SMESHOp::OpRemoveNodes:
3294 if(checkLock(aStudy)) break;
3296 EmitSignalDeactivateDialog();
3297 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3300 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3301 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3305 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3307 if(checkLock(aStudy)) break;
3309 EmitSignalDeactivateDialog();
3310 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3314 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3315 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3319 case SMESHOp::OpClearMesh: {
3321 if(checkLock(aStudy)) break;
3323 SALOME_ListIO selected;
3324 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3325 aSel->selectedObjects( selected );
3327 SUIT_OverrideCursor wc;
3328 SALOME_ListIteratorOfListIO It (selected);
3329 for ( ; It.More(); It.Next() )
3331 Handle(SALOME_InteractiveObject) IOS = It.Value();
3332 SMESH::SMESH_Mesh_var aMesh =
3333 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3334 if ( aMesh->_is_nil()) continue;
3336 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3338 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3339 SMESH::ModifiedMesh( aMeshSObj, false, true);
3340 // hide groups and submeshes
3341 _PTR(ChildIterator) anIter =
3342 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3343 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3345 _PTR(SObject) so = anIter->Value();
3346 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3349 catch (const SALOME::SALOME_Exception& S_ex){
3351 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3355 SMESH::UpdateView();
3359 case SMESHOp::OpRemoveOrphanNodes:
3361 if(checkLock(aStudy)) break;
3362 SALOME_ListIO selected;
3363 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3364 aSel->selectedObjects( selected );
3365 if ( selected.Extent() == 1 ) {
3366 Handle(SALOME_InteractiveObject) anIO = selected.First();
3367 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3368 if ( !aMesh->_is_nil() ) {
3369 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3370 tr( "SMESH_WARNING" ),
3371 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3372 SUIT_MessageBox::Yes |
3373 SUIT_MessageBox::No,
3374 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3377 SUIT_OverrideCursor wc;
3378 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3379 int removed = aMeshEditor->RemoveOrphanNodes();
3380 SUIT_MessageBox::information(SMESHGUI::desktop(),
3381 tr("SMESH_INFORMATION"),
3382 tr("NB_NODES_REMOVED").arg(removed));
3383 if ( removed > 0 ) {
3384 SMESH::UpdateView();
3385 SMESHGUI::Modified();
3388 catch (const SALOME::SALOME_Exception& S_ex) {
3389 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3398 case SMESHOp::OpRenumberingNodes:
3400 if(checkLock(aStudy)) break;
3402 EmitSignalDeactivateDialog();
3403 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3407 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3408 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3412 case SMESHOp::OpRenumberingElements:
3414 if(checkLock(aStudy)) break;
3416 EmitSignalDeactivateDialog();
3417 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3421 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3422 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3426 case SMESHOp::OpTranslation:
3428 if(checkLock(aStudy)) break;
3430 EmitSignalDeactivateDialog();
3431 ( new SMESHGUI_TranslationDlg( this ) )->show();
3434 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3435 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3439 case SMESHOp::OpRotation:
3441 if(checkLock(aStudy)) break;
3443 EmitSignalDeactivateDialog();
3444 ( new SMESHGUI_RotationDlg( this ) )->show();
3447 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3448 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3452 case SMESHOp::OpSymmetry:
3454 if(checkLock(aStudy)) break;
3456 EmitSignalDeactivateDialog();
3457 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3460 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3461 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465 case SMESHOp::OpScale:
3467 if(checkLock(aStudy)) break;
3469 EmitSignalDeactivateDialog();
3470 ( new SMESHGUI_ScaleDlg( this ) )->show();
3473 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3474 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3479 case SMESHOp::OpSewing:
3481 if(checkLock(aStudy)) break;
3483 EmitSignalDeactivateDialog();
3484 ( new SMESHGUI_SewingDlg( this ) )->show();
3487 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3488 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3492 case SMESHOp::OpMergeNodes:
3494 if(checkLock(aStudy)) break;
3496 EmitSignalDeactivateDialog();
3497 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3500 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3501 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3505 case SMESHOp::OpMergeElements:
3507 if (checkLock(aStudy)) break;
3509 EmitSignalDeactivateDialog();
3510 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3512 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3513 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3518 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3519 startOperation( SMESHOp::OpMoveNode );
3522 case SMESHOp::OpDuplicateNodes:
3524 if(checkLock(aStudy)) break;
3526 EmitSignalDeactivateDialog();
3527 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3530 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3531 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3536 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3537 startOperation( SMESHOp::OpElem0DOnElemNodes );
3540 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3542 static QList<int> aTypes;
3543 if ( aTypes.isEmpty() )
3545 aTypes.append( SMESH::NODE );
3546 aTypes.append( SMESH::EDGE );
3547 aTypes.append( SMESH::FACE );
3548 aTypes.append( SMESH::VOLUME );
3550 if (!myFilterLibraryDlg)
3551 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3552 else if (myFilterLibraryDlg->isHidden())
3553 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3554 myFilterLibraryDlg->raise();
3558 case SMESHOp::OpFreeNode:
3559 case SMESHOp::OpEqualNode:
3560 case SMESHOp::OpFreeEdge:
3561 case SMESHOp::OpFreeBorder:
3562 case SMESHOp::OpLength:
3563 case SMESHOp::OpConnection:
3564 case SMESHOp::OpEqualEdge:
3565 case SMESHOp::OpFreeFace:
3566 case SMESHOp::OpBareBorderFace:
3567 case SMESHOp::OpOverConstrainedFace:
3568 case SMESHOp::OpLength2D:
3569 case SMESHOp::OpConnection2D:
3570 case SMESHOp::OpArea:
3571 case SMESHOp::OpTaper:
3572 case SMESHOp::OpAspectRatio:
3573 case SMESHOp::OpMinimumAngle:
3574 case SMESHOp::OpWarpingAngle:
3575 case SMESHOp::OpSkew:
3576 case SMESHOp::OpMaxElementLength2D:
3577 case SMESHOp::OpEqualFace:
3578 case SMESHOp::OpAspectRatio3D:
3579 case SMESHOp::OpVolume:
3580 case SMESHOp::OpMaxElementLength3D:
3581 case SMESHOp::OpBareBorderVolume:
3582 case SMESHOp::OpOverConstrainedVolume:
3583 case SMESHOp::OpEqualVolume:
3586 LightApp_SelectionMgr* mgr = selectionMgr();
3587 SALOME_ListIO selected; mgr->selectedObjects( selected );
3589 if( !selected.IsEmpty() ) {
3590 SUIT_OverrideCursor wc;
3591 ::Control( theCommandID );
3594 SUIT_MessageBox::warning(desktop(),
3595 tr( "SMESH_WRN_WARNING" ),
3596 tr( "SMESH_BAD_SELECTION" ) );
3600 SUIT_MessageBox::warning(desktop(),
3601 tr( "SMESH_WRN_WARNING" ),
3602 tr( "NOT_A_VTK_VIEWER" ) );
3605 case SMESHOp::OpOverallMeshQuality:
3606 OverallMeshQuality();
3608 case SMESHOp::OpNumberingNodes:
3610 SUIT_OverrideCursor wc;
3611 LightApp_SelectionMgr* mgr = selectionMgr();
3612 SALOME_ListIO selected; mgr->selectedObjects( selected );
3614 SALOME_ListIteratorOfListIO it(selected);
3615 for( ; it.More(); it.Next()) {
3616 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3617 if(anIObject->hasEntry()) {
3618 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3619 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3625 case SMESHOp::OpNumberingElements:
3627 SUIT_OverrideCursor wc;
3628 LightApp_SelectionMgr* mgr = selectionMgr();
3629 SALOME_ListIO selected; mgr->selectedObjects( selected );
3631 SALOME_ListIteratorOfListIO it(selected);
3632 for( ; it.More(); it.Next()) {
3633 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3634 if(anIObject->hasEntry())
3635 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3636 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3641 case SMESHOp::OpPropertiesLength:
3642 case SMESHOp::OpPropertiesArea:
3643 case SMESHOp::OpPropertiesVolume:
3644 case SMESHOp::OpMinimumDistance:
3645 case SMESHOp::OpBoundingBox:
3647 int page = SMESHGUI_MeasureDlg::MinDistance;
3648 if ( theCommandID == SMESHOp::OpBoundingBox )
3649 page = SMESHGUI_MeasureDlg::BoundingBox;
3650 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3651 page = SMESHGUI_MeasureDlg::Length;
3652 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3653 page = SMESHGUI_MeasureDlg::Area;
3654 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3655 page = SMESHGUI_MeasureDlg::Volume;
3657 EmitSignalDeactivateDialog();
3658 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3662 case SMESHOp::OpSortChild:
3668 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3669 //updateObjBrowser();
3673 //=============================================================================
3677 //=============================================================================
3678 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3683 //=============================================================================
3687 //=============================================================================
3688 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3693 //=============================================================================
3697 //=============================================================================
3698 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3703 //=============================================================================
3704 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3705 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3707 //=============================================================================
3708 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3709 SUIT_ViewWindow* wnd )
3711 if(theIO->hasEntry()){
3712 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3713 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3717 //=======================================================================
3718 // function : createSMESHAction
3720 //=======================================================================
3721 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3722 const int key, const bool toggle, const QString& shortcutAction )
3725 QWidget* parent = application()->desktop();
3726 SUIT_ResourceMgr* resMgr = resourceMgr();
3728 if ( !icon_id.isEmpty() )
3729 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3731 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3732 if ( !pix.isNull() )
3733 icon = QIcon( pix );
3735 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3736 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3737 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3739 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3740 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3743 //=======================================================================
3744 // function : createPopupItem
3746 //=======================================================================
3747 void SMESHGUI::createPopupItem( const int id,
3748 const QString& clients,
3749 const QString& types,
3750 const QString& theRule,
3753 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3754 popupMgr()->insert( action( id ), pId, 0 );
3756 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3757 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3758 QString rule = "(%1) and (%2) and (%3)";
3759 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3760 if( clients.isEmpty() )
3761 rule = rule.arg( QString( "true" ) );
3763 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3764 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3767 bool cont = myRules.contains( id );
3769 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3771 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3772 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3775 //=======================================================================
3776 // function : initialize
3778 //=======================================================================
3779 void SMESHGUI::initialize( CAM_Application* app )
3781 SalomeApp_Module::initialize( app );
3783 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3785 /* Automatic Update flag */
3786 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3788 // ----- create actions --------------
3790 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3791 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3792 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3793 //createSMESHAction( 114, "NUM" );
3794 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3796 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3798 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3799 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3800 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3801 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3802 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3803 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3805 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3807 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3808 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3809 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3810 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3811 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3812 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3814 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3816 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3817 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3818 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3819 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3820 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3821 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3822 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3823 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3824 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3825 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3826 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3827 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3828 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3829 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3830 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3831 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3832 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3833 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3834 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3835 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3836 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3837 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3838 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3839 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3840 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3841 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3842 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3843 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3844 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3845 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3847 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3848 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3849 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3850 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3851 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3852 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3853 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3854 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3855 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3856 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3857 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3858 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3859 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3860 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3861 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3862 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3863 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3864 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3865 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3866 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3867 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3868 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3869 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3870 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3871 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3872 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3873 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3875 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3876 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3877 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3878 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3879 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3880 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3881 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3882 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3883 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3884 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3885 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3886 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3887 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3888 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3889 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3890 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3891 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3892 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3893 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3894 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3895 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3896 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3897 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3898 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3900 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3901 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3902 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3903 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3905 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3906 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3908 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3909 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3910 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3911 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3912 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3913 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3914 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3915 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3916 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3917 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3918 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3919 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3920 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3921 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3922 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3923 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3924 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3925 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3926 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3927 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3928 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3929 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3930 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3932 createSMESHAction( SMESHOp::OpReset, "RESET" );
3933 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3934 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3935 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3936 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3937 #ifndef DISABLE_PLOT2DVIEWER
3938 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3940 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3941 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3942 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3943 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3944 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3945 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3946 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3947 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3948 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3949 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3950 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3951 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3952 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3954 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3955 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3957 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3958 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3959 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3960 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3961 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3962 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3963 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3964 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3965 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3967 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3968 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3969 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3970 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3971 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3973 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3974 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3975 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3977 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3979 QList<int> aCtrlActions;
3980 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3981 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3982 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3983 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3984 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3985 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3986 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3987 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3988 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3989 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3990 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3991 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3992 aCtrlGroup->setExclusive( true );
3993 for( int i = 0; i < aCtrlActions.size(); i++ )
3994 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3996 // ----- create menu --------------
3997 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3998 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3999 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4000 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4001 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4002 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4003 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4004 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4006 createMenu( separator(), fileId );
4008 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4009 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4010 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
4011 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
4012 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
4013 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
4014 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4015 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4016 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4017 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4018 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4020 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4021 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4022 createMenu( SMESHOp::OpImportMED, importId, -1 );
4023 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4025 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4027 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4028 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4029 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4030 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4031 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4032 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4034 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4036 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4037 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4038 createMenu( separator(), fileId, 10 );
4040 createMenu( SMESHOp::OpDelete, editId, -1 );
4042 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4044 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4045 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4046 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4047 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4048 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4049 createMenu( separator(), meshId, -1 );
4050 createMenu( SMESHOp::OpCompute, meshId, -1 );
4051 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4052 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4053 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4054 createMenu( separator(), meshId, -1 );
4055 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4056 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4057 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4058 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4059 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4060 createMenu( separator(), meshId, -1 );
4061 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4062 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4063 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4064 createMenu( separator(), meshId, -1 );
4065 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4066 createMenu( separator(), meshId, -1 );
4067 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4068 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4069 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4070 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4071 createMenu( separator(), meshId, -1 );
4073 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4074 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4075 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4076 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4077 createMenu( SMESHOp::OpLength, edgeId, -1 );
4078 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4079 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4080 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4081 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4082 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4083 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4084 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4085 createMenu( SMESHOp::OpArea, faceId, -1 );
4086 createMenu( SMESHOp::OpTaper, faceId, -1 );
4087 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4088 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4089 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4090 createMenu( SMESHOp::OpSkew, faceId, -1 );
4091 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4092 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4093 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4094 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4095 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4096 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4097 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4098 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4099 createMenu( separator(), ctrlId, -1 );
4100 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4101 createMenu( separator(), ctrlId, -1 );
4102 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4104 createMenu( SMESHOp::OpNode, addId, -1 );
4105 createMenu( SMESHOp::OpElem0D, addId, -1 );
4106 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4107 createMenu( SMESHOp::OpBall, addId, -1 );
4108 createMenu( SMESHOp::OpEdge, addId, -1 );
4109 createMenu( SMESHOp::OpTriangle, addId, -1 );
4110 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4111 createMenu( SMESHOp::OpPolygon, addId, -1 );
4112 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4113 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4114 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4115 createMenu( SMESHOp::OpPyramid, addId, -1 );
4116 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4117 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4118 createMenu( separator(), addId, -1 );
4119 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4120 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4121 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4122 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4123 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4124 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4125 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4126 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4127 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4128 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4130 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4131 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4132 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4133 createMenu( separator(), removeId, -1 );
4134 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4135 createMenu( separator(), removeId, -1 );
4136 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4138 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4139 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4141 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4142 createMenu( SMESHOp::OpRotation, transfId, -1 );
4143 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4144 createMenu( SMESHOp::OpScale, transfId, -1 );
4145 createMenu( SMESHOp::OpSewing, transfId, -1 );
4146 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4147 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4148 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4150 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4151 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4152 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4153 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4154 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4155 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4156 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4157 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4158 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4159 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4160 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4161 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4162 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4163 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4164 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4166 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4167 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4168 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4169 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4170 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4171 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4173 // ----- create toolbars --------------
4174 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4175 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4176 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4177 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4178 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4179 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4180 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4181 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4182 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4183 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4184 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4185 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4186 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4187 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4188 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4190 createTool( SMESHOp::OpCreateMesh, meshTb );
4191 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4192 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4193 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4194 createTool( SMESHOp::OpCopyMesh, meshTb );
4195 createTool( separator(), meshTb );
4196 createTool( SMESHOp::OpCompute, meshTb );
4197 createTool( SMESHOp::OpPreCompute, meshTb );
4198 createTool( SMESHOp::OpEvaluate, meshTb );
4199 createTool( SMESHOp::OpMeshOrder, meshTb );
4201 createTool( SMESHOp::OpCreateGroup, groupTb );
4202 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4203 createTool( SMESHOp::OpConstructGroup, groupTb );
4204 createTool( SMESHOp::OpEditGroup, groupTb );
4206 createTool( SMESHOp::OpMeshInformation, info );
4207 //createTool( SMESHOp::OpStdInfo, meshTb );
4208 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4209 createTool( SMESHOp::OpFindElementByPoint, info );
4211 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4212 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4214 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4215 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4216 createTool( SMESHOp::OpLength, ctrl1dTb );
4217 createTool( SMESHOp::OpConnection, ctrl1dTb );
4218 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4220 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4221 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4222 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4223 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4224 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4225 createTool( SMESHOp::OpArea, ctrl2dTb );
4226 createTool( SMESHOp::OpTaper, ctrl2dTb );
4227 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4228 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4229 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4230 createTool( SMESHOp::OpSkew, ctrl2dTb );
4231 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4232 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4234 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4235 createTool( SMESHOp::OpVolume, ctrl3dTb );
4236 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4237 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4238 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4239 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4241 createTool( SMESHOp::OpNode, addElemTb );
4242 createTool( SMESHOp::OpElem0D, addElemTb );
4243 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4244 createTool( SMESHOp::OpBall, addElemTb );
4245 createTool( SMESHOp::OpEdge, addElemTb );
4246 createTool( SMESHOp::OpTriangle, addElemTb );
4247 createTool( SMESHOp::OpQuadrangle, addElemTb );
4248 createTool( SMESHOp::OpPolygon, addElemTb );
4249 createTool( SMESHOp::OpTetrahedron, addElemTb );
4250 createTool( SMESHOp::OpHexahedron, addElemTb );
4251 createTool( SMESHOp::OpPentahedron, addElemTb );
4252 createTool( SMESHOp::OpPyramid, addElemTb );
4253 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4254 createTool( SMESHOp::OpPolyhedron, addElemTb );
4256 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4257 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4258 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4259 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4260 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4261 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4262 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4263 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4264 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4265 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4267 createTool( SMESHOp::OpRemoveNodes, remTb );
4268 createTool( SMESHOp::OpRemoveElements, remTb );
4269 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4270 createTool( SMESHOp::OpClearMesh, remTb );
4272 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4273 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4275 createTool( SMESHOp::OpTranslation, transformTb );
4276 createTool( SMESHOp::OpRotation, transformTb );
4277 createTool( SMESHOp::OpSymmetry, transformTb );
4278 createTool( SMESHOp::OpScale, transformTb );
4279 createTool( SMESHOp::OpSewing, transformTb );
4280 createTool( SMESHOp::OpMergeNodes, transformTb );
4281 createTool( SMESHOp::OpMergeElements, transformTb );
4282 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4284 createTool( SMESHOp::OpMoveNode, modifyTb );
4285 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4286 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4287 createTool( SMESHOp::OpOrientation, modifyTb );
4288 createTool( SMESHOp::OpReorientFaces, modifyTb );
4289 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4290 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4291 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4292 createTool( SMESHOp::OpSmoothing, modifyTb );
4293 createTool( SMESHOp::OpExtrusion, modifyTb );
4294 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4295 createTool( SMESHOp::OpRevolution, modifyTb );
4296 createTool( SMESHOp::OpPatternMapping, modifyTb );
4297 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4298 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4300 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4302 createTool( SMESHOp::OpUpdate, dispModeTb );
4304 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4305 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4308 QString OB = "'ObjectBrowser'",
4309 View = "'" + SVTK_Viewer::Type() + "'",
4311 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4312 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4313 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4314 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4315 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4316 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4317 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4318 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4319 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4320 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4321 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4323 mesh_part = mesh + " " + subMesh + " " + group,
4324 mesh_group = mesh + " " + group,
4325 hyp_alg = hypo + " " + algo;
4327 // popup for object browser
4329 isInvisible("not( isVisible )"),
4330 isEmpty("numberOfNodes = 0"),
4331 isNotEmpty("numberOfNodes <> 0"),
4333 // has nodes, edges, etc in VISIBLE! actor
4334 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4335 hasElems("(count( elemTypes ) > 0)"),
4336 hasDifferentElems("(count( elemTypes ) > 1)"),
4337 hasBalls("({'BallElem'} in elemTypes)"),
4338 hasElems0d("({'Elem0d'} in elemTypes)"),
4339 hasEdges("({'Edge'} in elemTypes)"),
4340 hasFaces("({'Face'} in elemTypes)"),
4341 hasVolumes("({'Volume'} in elemTypes)");
4343 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4344 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4345 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4346 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4347 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4348 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4350 popupMgr()->insert( separator(), -1, 0 );
4351 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4352 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4353 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4354 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4355 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4356 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4357 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4358 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4359 popupMgr()->insert( separator(), -1, 0 );
4360 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4361 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4362 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4363 popupMgr()->insert( separator(), -1, 0 );
4364 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4365 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4366 popupMgr()->insert( separator(), -1, 0 );
4367 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4368 popupMgr()->insert( separator(), -1, 0 );
4369 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4370 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4372 popupMgr()->insert( separator(), -1, 0 );
4374 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4375 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4376 QString only_one_2D = only_one_non_empty + " && dim>1";
4378 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4379 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4380 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4381 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4383 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4385 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4386 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4387 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4388 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4389 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4390 popupMgr()->insert( separator(), -1, 0 );
4393 createPopupItem( SMESHOp::OpEditGroup, View, group );
4394 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4395 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4397 popupMgr()->insert( separator(), -1, 0 );
4398 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4399 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4400 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4401 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4402 popupMgr()->insert( separator(), -1, 0 );
4404 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4405 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4406 popupMgr()->insert( separator(), -1, 0 );
4408 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4409 QString aType = QString( "%1type in {%2}" ).arg( lc );
4410 aType = aType.arg( mesh_part );
4411 QString aMeshInVTK = aClient + "&&" + aType;
4413 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4414 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4415 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4417 //-------------------------------------------------
4419 //-------------------------------------------------
4420 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4422 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4423 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4424 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4426 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4427 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4428 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4430 popupMgr()->insert( separator(), -1, -1 );
4432 //-------------------------------------------------
4434 //-------------------------------------------------
4435 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4437 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4438 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4439 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4441 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4442 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4443 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4445 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4446 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4447 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4449 popupMgr()->insert( separator(), anId, -1 );
4451 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4452 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4453 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4455 //-------------------------------------------------
4457 //-------------------------------------------------
4458 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4460 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4462 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4463 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4464 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4466 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4467 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4468 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4470 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4471 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4472 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4474 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4475 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4476 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4478 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4479 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4480 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4482 popupMgr()->insert( separator(), anId, -1 );
4484 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4485 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4487 popupMgr()->insert( separator(), anId, -1 );
4489 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4490 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4493 //-------------------------------------------------
4494 // Representation of the 2D Quadratic elements
4495 //-------------------------------------------------
4496 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4497 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4498 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4499 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4501 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4502 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4503 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4505 //-------------------------------------------------
4506 // Orientation of faces
4507 //-------------------------------------------------
4508 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4509 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4510 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4512 //-------------------------------------------------
4514 //-------------------------------------------------
4515 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4516 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4518 //-------------------------------------------------
4520 //-------------------------------------------------
4521 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4522 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4524 //-------------------------------------------------
4526 //-------------------------------------------------
4528 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4529 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4530 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4531 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4533 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4535 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4536 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4538 popupMgr()->insert( separator(), anId, -1 );
4540 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4542 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4543 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4544 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4546 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4547 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4548 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4550 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4552 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4557 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4558 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4560 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4561 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4562 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4564 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4565 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4566 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4567 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4568 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4569 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4571 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4573 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4575 QtxPopupMgr::VisibleRule );
4576 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4578 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4579 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4580 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4582 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4583 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4584 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4586 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4587 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4588 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4590 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4592 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4594 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4595 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4596 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4598 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4600 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4602 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4603 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4606 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4614 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4615 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4616 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4618 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4619 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4620 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4621 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4623 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4625 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4627 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4629 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4631 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4633 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4635 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4636 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4637 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4639 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4640 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4641 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4643 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4644 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4645 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4647 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4649 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert( separator(), anId, -1 );
4653 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4656 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4657 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4659 popupMgr()->insert( separator(), anId, -1 );
4661 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4663 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4666 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4668 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4670 #ifndef DISABLE_PLOT2DVIEWER
4671 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4675 //-------------------------------------------------
4677 //-------------------------------------------------
4678 popupMgr()->insert( separator(), -1, -1 );
4679 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4680 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4681 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4682 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4684 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4687 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4688 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4690 popupMgr()->insert( separator(), -1, -1 );
4692 //-------------------------------------------------
4694 //-------------------------------------------------
4695 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4698 popupMgr()->insert( separator(), -1, -1 );
4700 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4701 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4702 popupMgr()->insert( separator(), -1, -1 );
4704 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4705 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4707 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4708 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4711 //================================================================================
4713 * \brief Return true if SMESH or GEOM objects are selected.
4714 * Is called form LightApp_Module::activateModule() which clear selection if
4715 * not isSelectionCompatible()
4717 //================================================================================
4719 bool SMESHGUI::isSelectionCompatible()
4721 bool isCompatible = true;
4722 SALOME_ListIO selected;
4723 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4724 Sel->selectedObjects( selected );
4726 SALOME_ListIteratorOfListIO It( selected );
4727 for ( ; isCompatible && It.More(); It.Next())
4729 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4730 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4732 return isCompatible;
4736 bool SMESHGUI::reusableOperation( const int id )
4738 // compute, evaluate and precompute are not reusable operations
4739 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4742 bool SMESHGUI::activateModule( SUIT_Study* study )
4744 bool res = SalomeApp_Module::activateModule( study );
4746 setMenuShown( true );
4747 setToolShown( true );
4749 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4750 PyGILState_STATE gstate = PyGILState_Ensure();
4751 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4752 if ( !pluginsmanager ) {
4756 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4760 PyGILState_Release(gstate);
4761 // end of SMESH plugins loading
4763 // Reset actions accelerator keys
4764 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4766 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4767 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4768 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4769 if ( _PTR(Study) aStudy = s->studyDS()) {
4770 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4771 updateObjBrowser(); // objects can be removed
4774 // get all view currently opened in the study and connect their signals to
4775 // the corresponding slots of the class.
4776 SUIT_Desktop* aDesk = study->application()->desktop();
4778 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4779 SUIT_ViewWindow* wnd;
4780 foreach ( wnd, wndList )
4787 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4789 setMenuShown( false );
4790 setToolShown( false );
4792 EmitSignalCloseAllDialogs();
4794 // Unset actions accelerator keys
4795 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4797 return SalomeApp_Module::deactivateModule( study );
4800 void SMESHGUI::studyClosed( SUIT_Study* s )
4804 SMESH::RemoveVisuData( s->id() );
4805 SalomeApp_Module::studyClosed( s );
4808 void SMESHGUI::OnGUIEvent()
4810 const QObject* obj = sender();
4811 if ( !obj || !obj->inherits( "QAction" ) )
4813 int id = actionId((QAction*)obj);
4818 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4820 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4821 if ( CORBA::is_nil( myComponentSMESH ) )
4823 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4825 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4826 return aGUI.myComponentSMESH;
4829 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4830 return myComponentSMESH;
4833 QString SMESHGUI::engineIOR() const
4835 CORBA::ORB_var anORB = getApp()->orb();
4836 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4837 return QString( anIOR.in() );
4840 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4842 SalomeApp_Module::contextMenuPopup( client, menu, title );
4844 selectionMgr()->selectedObjects( lst );
4845 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4846 Handle(SALOME_InteractiveObject) io = lst.First();
4847 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4848 _PTR(Study) study = appStudy->studyDS();
4849 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4851 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4852 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4853 aName.remove( (aName.length() - 1), 1 );
4859 LightApp_Selection* SMESHGUI::createSelection() const
4861 return new SMESHGUI_Selection();
4864 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4866 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4867 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4868 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4871 void SMESHGUI::viewManagers( QStringList& list ) const
4873 list.append( SVTK_Viewer::Type() );
4876 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4878 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4879 SMESH::UpdateSelectionProp( this );
4881 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4882 for(int i = 0; i < aViews.count() ; i++){
4883 SUIT_ViewWindow *sf = aViews[i];
4889 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4891 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4892 myClippingPlaneInfoMap.erase( theViewManager );
4895 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4897 theActor->AddObserver( SMESH::DeleteActorEvent,
4898 myEventCallbackCommand.GetPointer(),
4902 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4903 unsigned long theEvent,
4904 void* theClientData,
4907 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4908 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4909 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4910 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4911 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4912 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4913 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4914 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4915 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4916 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4917 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4918 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4919 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4920 if( anActor == *anIter3 ) {
4921 anActorList.erase( anIter3 );
4932 void SMESHGUI::createPreferences()
4934 // General tab ------------------------------------------------------------------------
4935 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4937 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4938 setPreferenceProperty( autoUpdate, "columns", 2 );
4939 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4940 setPreferenceProperty( lim, "min", 0 );
4941 setPreferenceProperty( lim, "max", 100000000 );
4942 setPreferenceProperty( lim, "step", 1000 );
4943 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4944 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4946 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4947 setPreferenceProperty( qaGroup, "columns", 2 );
4948 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4949 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4950 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4951 setPreferenceProperty( prec, "min", 0 );
4952 setPreferenceProperty( prec, "max", 100 );
4953 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4954 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4955 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4956 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4957 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4959 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4960 setPreferenceProperty( dispgroup, "columns", 2 );
4961 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4963 modes.append( tr("MEN_WIRE") );
4964 modes.append( tr("MEN_SHADE") );
4965 modes.append( tr("MEN_NODES") );
4966 modes.append( tr("MEN_SHRINK") );
4967 QList<QVariant> indices;
4968 indices.append( 0 );
4969 indices.append( 1 );
4970 indices.append( 2 );
4971 indices.append( 3 );
4972 setPreferenceProperty( dispmode, "strings", modes );
4973 setPreferenceProperty( dispmode, "indexes", indices );
4975 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4976 setPreferenceProperty( arcgroup, "columns", 2 );
4977 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4978 QStringList quadraticModes;
4979 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4980 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4982 indices.append( 0 );
4983 indices.append( 1 );
4984 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4985 setPreferenceProperty( quadraticmode, "indexes", indices );
4987 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4988 "SMESH", "max_angle" );
4989 setPreferenceProperty( maxAngle, "min", 1 );
4990 setPreferenceProperty( maxAngle, "max", 90 );
4994 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4995 setPreferenceProperty( exportgroup, "columns", 2 );
4996 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4997 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4999 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5000 setPreferenceProperty( computeGroup, "columns", 2 );
5001 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5003 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5004 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5005 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5007 indices.append( 0 );
5008 indices.append( 1 );
5009 indices.append( 2 );
5010 setPreferenceProperty( notifyMode, "strings", modes );
5011 setPreferenceProperty( notifyMode, "indexes", indices );
5013 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5014 setPreferenceProperty( infoGroup, "columns", 2 );
5015 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5017 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5018 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5020 indices.append( 0 );
5021 indices.append( 1 );
5022 setPreferenceProperty( elemInfo, "strings", modes );
5023 setPreferenceProperty( elemInfo, "indexes", indices );
5024 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5025 setPreferenceProperty( nodesLim, "min", 0 );
5026 setPreferenceProperty( nodesLim, "max", 10000000 );
5027 setPreferenceProperty( nodesLim, "step", 10000 );
5028 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5029 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5030 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5031 setPreferenceProperty( ctrlLim, "min", 0 );
5032 setPreferenceProperty( ctrlLim, "max", 10000000 );
5033 setPreferenceProperty( ctrlLim, "step", 1000 );
5034 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5035 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5036 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5037 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5038 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5040 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5041 setPreferenceProperty( segGroup, "columns", 2 );
5042 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5043 "SMESH", "segmentation" );
5044 setPreferenceProperty( segLen, "min", 1 );
5045 setPreferenceProperty( segLen, "max", 10000000 );
5046 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5047 "SMESH", "nb_segments_per_edge" );
5048 setPreferenceProperty( nbSeg, "min", 1 );
5049 setPreferenceProperty( nbSeg, "max", 10000000 );
5051 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5052 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5053 "SMESH", "forget_mesh_on_hyp_modif" );
5056 // Quantities with individual precision settings
5057 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5058 setPreferenceProperty( precGroup, "columns", 2 );
5060 const int nbQuantities = 6;
5061 int precs[nbQuantities], ii = 0;
5062 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5063 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5064 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5065 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5066 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5067 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5068 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5069 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5070 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5071 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5072 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5073 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5075 // Set property for precision value for spinboxes
5076 for ( ii = 0; ii < nbQuantities; ii++ ){
5077 setPreferenceProperty( precs[ii], "min", -14 );
5078 setPreferenceProperty( precs[ii], "max", 14 );
5079 setPreferenceProperty( precs[ii], "precision", 2 );
5082 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5083 setPreferenceProperty( previewGroup, "columns", 2 );
5084 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5085 setPreferenceProperty( chunkSize, "min", 1 );
5086 setPreferenceProperty( chunkSize, "max", 1000 );
5087 setPreferenceProperty( chunkSize, "step", 50 );
5089 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5090 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5092 // Mesh tab ------------------------------------------------------------------------
5093 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5094 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5095 setPreferenceProperty( nodeGroup, "columns", 3 );
5097 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5099 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5101 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5102 QList<QVariant> aMarkerTypeIndicesList;
5103 QList<QVariant> aMarkerTypeIconsList;
5104 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5105 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5106 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5107 aMarkerTypeIndicesList << i;
5108 aMarkerTypeIconsList << pixmap;
5110 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5111 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5113 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5115 QList<QVariant> aMarkerScaleIndicesList;
5116 QStringList aMarkerScaleValuesList;
5117 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5118 aMarkerScaleIndicesList << i;
5119 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5121 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5122 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5124 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5125 //setPreferenceProperty( elemGroup, "columns", 2 );
5127 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5128 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5129 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5130 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5131 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5132 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5133 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5134 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5135 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5138 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5139 setPreferenceProperty( grpGroup, "columns", 2 );
5141 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5142 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5144 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5145 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5146 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5147 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5148 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5149 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5150 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5151 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5152 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5153 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5154 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5155 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5156 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5157 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5159 setPreferenceProperty( size0d, "min", 1 );
5160 setPreferenceProperty( size0d, "max", 10 );
5162 // setPreferenceProperty( ballSize, "min", 1 );
5163 // setPreferenceProperty( ballSize, "max", 10 );
5165 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5166 setPreferenceProperty( ballDiameter, "max", 1e9 );
5167 setPreferenceProperty( ballDiameter, "step", 0.1 );
5169 setPreferenceProperty( ballScale, "min", 1e-2 );
5170 setPreferenceProperty( ballScale, "max", 1e7 );
5171 setPreferenceProperty( ballScale, "step", 0.5 );
5173 setPreferenceProperty( elemW, "min", 1 );
5174 setPreferenceProperty( elemW, "max", 5 );
5176 setPreferenceProperty( outW, "min", 1 );
5177 setPreferenceProperty( outW, "max", 5 );
5179 setPreferenceProperty( shrink, "min", 0 );
5180 setPreferenceProperty( shrink, "max", 100 );
5182 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5183 setPreferenceProperty( numGroup, "columns", 2 );
5185 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5186 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5188 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5189 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5191 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5192 setPreferenceProperty( orientGroup, "columns", 1 );
5194 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5195 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5197 setPreferenceProperty( orientScale, "min", 0.05 );
5198 setPreferenceProperty( orientScale, "max", 0.5 );
5199 setPreferenceProperty( orientScale, "step", 0.05 );
5201 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5203 // Selection tab ------------------------------------------------------------------------
5204 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5206 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5207 setPreferenceProperty( selGroup, "columns", 2 );
5209 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5210 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5212 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5213 setPreferenceProperty( preGroup, "columns", 2 );
5215 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5217 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5218 setPreferenceProperty( precSelGroup, "columns", 2 );
5220 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5221 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5222 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5224 // Scalar Bar tab ------------------------------------------------------------------------
5225 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5226 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5227 setPreferenceProperty( fontGr, "columns", 2 );
5229 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5230 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5232 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5233 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5235 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5236 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5238 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5239 setPreferenceProperty( numcol, "min", 2 );
5240 setPreferenceProperty( numcol, "max", 256 );
5242 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5243 setPreferenceProperty( numlab, "min", 2 );
5244 setPreferenceProperty( numlab, "max", 65 );
5246 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5247 setPreferenceProperty( orientGr, "columns", 2 );
5248 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5249 QStringList orients;
5250 orients.append( tr( "SMESH_VERTICAL" ) );
5251 orients.append( tr( "SMESH_HORIZONTAL" ) );
5252 indices.clear(); indices.append( 0 ); indices.append( 1 );
5253 setPreferenceProperty( orient, "strings", orients );
5254 setPreferenceProperty( orient, "indexes", indices );
5256 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5257 setPreferenceProperty( posVSizeGr, "columns", 2 );
5258 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5259 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5260 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5261 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5262 setPreferenceProperty( xv, "step", 0.1 );
5263 setPreferenceProperty( xv, "min", 0.0 );
5264 setPreferenceProperty( xv, "max", 1.0 );
5265 setPreferenceProperty( yv, "step", 0.1 );
5266 setPreferenceProperty( yv, "min", 0.0 );
5267 setPreferenceProperty( yv, "max", 1.0 );
5268 setPreferenceProperty( wv, "step", 0.1 );
5269 setPreferenceProperty( wv, "min", 0.0 );
5270 setPreferenceProperty( wv, "max", 1.0 );
5271 setPreferenceProperty( hv, "min", 0.0 );
5272 setPreferenceProperty( hv, "max", 1.0 );
5273 setPreferenceProperty( hv, "step", 0.1 );
5275 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5276 setPreferenceProperty( posHSizeGr, "columns", 2 );
5277 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5278 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5279 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5280 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5281 setPreferenceProperty( xv, "min", 0.0 );
5282 setPreferenceProperty( xv, "max", 1.0 );
5283 setPreferenceProperty( xv, "step", 0.1 );
5284 setPreferenceProperty( xh, "min", 0.0 );
5285 setPreferenceProperty( xh, "max", 1.0 );
5286 setPreferenceProperty( xh, "step", 0.1 );
5287 setPreferenceProperty( yh, "min", 0.0 );
5288 setPreferenceProperty( yh, "max", 1.0 );
5289 setPreferenceProperty( yh, "step", 0.1 );
5290 setPreferenceProperty( wh, "min", 0.0 );
5291 setPreferenceProperty( wh, "max", 1.0 );
5292 setPreferenceProperty( wh, "step", 0.1 );
5293 setPreferenceProperty( hh, "min", 0.0 );
5294 setPreferenceProperty( hh, "max", 1.0 );
5295 setPreferenceProperty( hh, "step", 0.1 );
5297 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5298 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5299 setPreferenceProperty( distributionGr, "columns", 3 );
5301 types.append( tr( "SMESH_MONOCOLOR" ) );
5302 types.append( tr( "SMESH_MULTICOLOR" ) );
5303 indices.clear(); indices.append( 0 ); indices.append( 1 );
5304 setPreferenceProperty( coloringType, "strings", types );
5305 setPreferenceProperty( coloringType, "indexes", indices );
5306 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5310 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5312 if( sect=="SMESH" ) {
5313 float sbX1,sbY1,sbW,sbH;
5314 float aTol = 1.00000009999999;
5315 std::string aWarning;
5316 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5317 if( name=="selection_object_color" || name=="selection_element_color" ||
5318 name=="highlight_color" ||
5319 name=="selection_precision_node" || name=="selection_precision_element" ||
5320 name=="selection_precision_object")
5321 SMESH::UpdateSelectionProp( this );
5322 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5323 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5324 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5325 if(sbX1+sbW > aTol){
5326 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5329 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5330 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5333 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5334 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5335 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5336 if(sbY1+sbH > aTol){
5337 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5338 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5339 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5342 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5343 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5344 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5345 if(sbX1+sbW > aTol){
5346 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5349 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5350 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5353 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5354 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5355 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5356 if(sbY1+sbH > aTol){
5357 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5360 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5361 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5364 else if ( name == "segmentation" ) {
5365 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5366 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5368 else if ( name == "nb_segments_per_edge" ) {
5369 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5370 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5372 else if ( name == "historical_python_dump" ||
5373 name == "forget_mesh_on_hyp_modif") {
5374 QString val = aResourceMgr->stringValue( "SMESH", name );
5375 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5377 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5378 SMESH::UpdateFontProp( this );
5380 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5381 SMESH::UpdateFontProp( this );
5384 if(aWarning.size() != 0){
5385 aWarning += "The default values are applied instead.";
5386 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5387 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5388 QObject::tr(aWarning.c_str()));
5393 //================================================================================
5395 * \brief Update something in accordance with update flags
5396 * \param theFlags - update flags
5398 * Update viewer or/and object browser etc. in accordance with update flags ( see
5399 * LightApp_UpdateFlags enumeration ).
5401 //================================================================================
5402 void SMESHGUI::update( const int flags )
5404 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5405 SMESH::UpdateView();
5407 SalomeApp_Module::update( flags );
5410 //================================================================================
5412 * \brief Set default selection mode
5414 * SLOT called when operation commited. Sets default selection mode
5416 //================================================================================
5417 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5419 SVTK_ViewWindow* vtkWnd =
5420 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5422 vtkWnd->SetSelectionMode( ActorSelection );
5425 //================================================================================
5427 * \brief Set default selection mode
5429 * SLOT called when operation aborted. Sets default selection mode
5431 //================================================================================
5432 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5434 SVTK_ViewWindow* vtkWnd =
5435 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5437 vtkWnd->SetSelectionMode( ActorSelection );
5440 //================================================================================
5442 * \brief Creates operation with given identifier
5443 * \param id - identifier of operation to be started
5444 * \return Pointer on created operation or NULL if operation is not created
5446 * Virtual method redefined from the base class creates operation with given id.
5447 * It is called called automatically from startOperation method of base class.
5449 //================================================================================
5450 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5452 LightApp_Operation* op = 0;
5453 // to do : create operation here
5456 case SMESHOp::OpConvertMeshToQuadratic:
5457 op = new SMESHGUI_ConvToQuadOp();
5459 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5460 op = new SMESHGUI_Make2DFrom3DOp();
5462 case SMESHOp::OpReorientFaces:
5463 op = new SMESHGUI_ReorientFacesOp();
5465 case SMESHOp::OpCreateMesh:
5466 op = new SMESHGUI_MeshOp( true, true );
5468 case SMESHOp::OpCreateSubMesh:
5469 op = new SMESHGUI_MeshOp( true, false );
5471 case SMESHOp::OpEditMeshOrSubMesh:
5472 op = new SMESHGUI_MeshOp( false );
5474 case SMESHOp::OpCompute:
5475 op = new SMESHGUI_ComputeOp();
5477 case SMESHOp::OpPreCompute:
5478 op = new SMESHGUI_PrecomputeOp();
5480 case SMESHOp::OpEvaluate:
5481 op = new SMESHGUI_EvaluateOp();
5483 case SMESHOp::OpMeshOrder:
5484 op = new SMESHGUI_MeshOrderOp();
5486 case SMESHOp::OpCreateGeometryGroup:
5487 op = new SMESHGUI_GroupOnShapeOp();
5489 case SMESHOp::OpFindElementByPoint:
5490 op = new SMESHGUI_FindElemByPointOp();
5492 case SMESHOp::OpMoveNode: // Make mesh pass through point
5493 op = new SMESHGUI_MakeNodeAtPointOp();
5495 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5496 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5503 op = SalomeApp_Module::createOperation( id );
5507 //================================================================================
5509 * \brief Stops current operations and starts a given one
5510 * \param id - The id of the operation to start
5512 //================================================================================
5514 void SMESHGUI::switchToOperation(int id)
5516 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5517 activeStudy()->abortAllOperations();
5518 startOperation( id );
5521 LightApp_Displayer* SMESHGUI::displayer()
5524 myDisplayer = new SMESHGUI_Displayer( getApp() );
5528 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5531 int aTolerance = 64;
5532 int anIterations = 0;
5538 if( anIterations % aPeriod == 0 )
5541 if( aTolerance < 1 )
5545 aHue = (int)( 360.0 * rand() / RAND_MAX );
5548 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5549 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5550 for( ; it != itEnd; ++it )
5552 SALOMEDS::Color anAutoColor = *it;
5553 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5556 aQColor.getHsv( &h, &s, &v );
5557 if( abs( h - aHue ) < aTolerance )
5569 aColor.setHsv( aHue, 255, 255 );
5571 SALOMEDS::Color aSColor;
5572 aSColor.R = aColor.redF();
5573 aSColor.G = aColor.greenF();
5574 aSColor.B = aColor.blueF();
5579 const char* gSeparator = "_"; // character used to separate parameter names
5580 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5581 const char* gPathSep = "|"; // character used to separate paths
5584 * \brief Store visual parameters
5586 * This method is called just before the study document is saved.
5587 * Store visual parameters in AttributeParameter attribue(s)
5589 void SMESHGUI::storeVisualParameters (int savePoint)
5592 Kernel_Utils::Localizer loc;
5594 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5595 if (!appStudy || !appStudy->studyDS())
5597 _PTR(Study) studyDS = appStudy->studyDS();
5599 // componentName is used for encoding of entries when storing them in IParameters
5600 std::string componentName = myComponentSMESH->ComponentDataType();
5601 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5602 //if (!aSComponent) return;
5605 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5606 componentName.c_str(),
5608 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5610 // store map of custom markers
5611 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5612 if( !aMarkerMap.empty() )
5614 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5615 for( ; anIter != aMarkerMap.end(); anIter++ )
5617 int anId = anIter->first;
5618 VTK::MarkerData aMarkerData = anIter->second;
5619 std::string aMarkerFileName = aMarkerData.first;
5620 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5621 if( aMarkerTexture.size() < 3 )
5622 continue; // should contain at least width, height and the first value
5624 QString aPropertyName( "texture" );
5625 aPropertyName += gSeparator;
5626 aPropertyName += QString::number( anId );
5628 QString aPropertyValue = aMarkerFileName.c_str();
5629 aPropertyValue += gPathSep;
5631 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5632 ushort aWidth = *aTextureIter++;
5633 ushort aHeight = *aTextureIter++;
5634 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5635 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5636 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5637 aPropertyValue += QString::number( *aTextureIter );
5639 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5643 // viewers counters are used for storing view_numbers in IParameters
5646 // main cycle to store parameters of displayed objects
5647 QList<SUIT_ViewManager*> lst;
5648 QList<SUIT_ViewManager*>::Iterator it;
5649 getApp()->viewManagers(lst);
5650 for (it = lst.begin(); it != lst.end(); it++)
5652 SUIT_ViewManager* vman = *it;
5653 QString vType = vman->getType();
5655 // saving VTK actors properties
5656 if (vType == SVTK_Viewer::Type())
5658 // store the clipping planes attached to the view manager
5659 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5660 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5661 if( anIter != myClippingPlaneInfoMap.end() )
5662 aClippingPlaneInfoList = anIter->second;
5664 if( !aClippingPlaneInfoList.empty() ) {
5665 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5666 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5668 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5669 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5671 QString aPropertyName( "ClippingPlane" );
5672 aPropertyName += gSeparator;
5673 aPropertyName += QString::number( vtkViewers );
5674 aPropertyName += gSeparator;
5675 aPropertyName += QString::number( anId );
5677 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5678 aPropertyValue += gDigitsSep;
5679 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5680 aPropertyValue += gDigitsSep;
5681 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5682 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5683 aPropertyValue += gDigitsSep;
5684 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5685 aPropertyValue += gDigitsSep;
5686 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5687 aPropertyValue += gDigitsSep;
5688 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5689 aPropertyValue += gDigitsSep;
5690 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5691 aPropertyValue += gDigitsSep;
5692 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5693 aPropertyValue += gDigitsSep;
5694 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5696 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5697 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5698 aPropertyValue += gDigitsSep;
5699 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5700 aPropertyValue += gDigitsSep;
5701 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5702 aPropertyValue += gDigitsSep;
5703 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5706 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5710 QVector<SUIT_ViewWindow*> views = vman->getViews();
5711 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5713 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5715 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5716 vtkActorCollection* allActors = aCopy.GetActors();
5717 allActors->InitTraversal();
5718 while (vtkActor* actor = allActors->GetNextActor())
5720 if (actor->GetVisibility()) // store only visible actors
5722 SMESH_Actor* aSmeshActor = 0;
5723 if (actor->IsA("SMESH_Actor"))
5724 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5725 if (aSmeshActor && aSmeshActor->hasIO())
5727 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5730 // entry is "encoded" = it does NOT contain component adress,
5731 // since it is a subject to change on next component loading
5732 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5734 std::string param, vtkParam = vType.toLatin1().data();
5735 vtkParam += gSeparator;
5736 vtkParam += QString::number(vtkViewers).toLatin1().data();
5737 vtkParam += gSeparator;
5740 param = vtkParam + "Visibility";
5741 ip->setParameter(entry, param, "On");
5744 param = vtkParam + "Representation";
5745 ip->setParameter(entry, param, QString::number
5746 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5749 param = vtkParam + "IsShrunk";
5750 ip->setParameter(entry, param, QString::number
5751 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5753 // Displayed entities
5754 unsigned int aMode = aSmeshActor->GetEntityMode();
5755 bool isE = aMode & SMESH_Actor::eEdges;
5756 bool isF = aMode & SMESH_Actor::eFaces;
5757 bool isV = aMode & SMESH_Actor::eVolumes;
5758 bool is0d = aMode & SMESH_Actor::e0DElements;
5759 bool isB = aMode & SMESH_Actor::eBallElem;
5761 QString modeStr ("e");
5762 modeStr += gDigitsSep; modeStr += QString::number(isE);
5763 modeStr += gDigitsSep; modeStr += "f";
5764 modeStr += gDigitsSep; modeStr += QString::number(isF);
5765 modeStr += gDigitsSep; modeStr += "v";
5766 modeStr += gDigitsSep; modeStr += QString::number(isV);
5767 modeStr += gDigitsSep; modeStr += "0d";
5768 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5769 modeStr += gDigitsSep; modeStr += "b";
5770 modeStr += gDigitsSep; modeStr += QString::number(isB);
5772 param = vtkParam + "Entities";
5773 ip->setParameter(entry, param, modeStr.toLatin1().data());
5779 aSmeshActor->GetSufaceColor(r, g, b, delta);
5780 QStringList colorStr;
5781 colorStr << "surface";
5782 colorStr << QString::number(r);
5783 colorStr << QString::number(g);
5784 colorStr << QString::number(b);
5786 colorStr << "backsurface";
5787 colorStr << QString::number(delta);
5789 aSmeshActor->GetVolumeColor(r, g, b, delta);
5790 colorStr << "volume";
5791 colorStr << QString::number(r);
5792 colorStr << QString::number(g);
5793 colorStr << QString::number(b);
5794 colorStr << QString::number(delta);
5796 aSmeshActor->GetEdgeColor(r, g, b);
5798 colorStr << QString::number(r);
5799 colorStr << QString::number(g);
5800 colorStr << QString::number(b);
5802 aSmeshActor->GetNodeColor(r, g, b);
5804 colorStr << QString::number(r);
5805 colorStr << QString::number(g);
5806 colorStr << QString::number(b);
5808 aSmeshActor->GetOutlineColor(r, g, b);
5809 colorStr << "outline";
5810 colorStr << QString::number(r);
5811 colorStr << QString::number(g);
5812 colorStr << QString::number(b);
5814 aSmeshActor->Get0DColor(r, g, b);
5815 colorStr << "elem0d";
5816 colorStr << QString::number(r);
5817 colorStr << QString::number(g);
5818 colorStr << QString::number(b);
5820 aSmeshActor->GetBallColor(r, g, b);
5822 colorStr << QString::number(r);
5823 colorStr << QString::number(g);
5824 colorStr << QString::number(b);
5826 aSmeshActor->GetFacesOrientationColor(r, g, b);
5827 colorStr << "orientation";
5828 colorStr << QString::number(r);
5829 colorStr << QString::number(g);
5830 colorStr << QString::number(b);
5832 param = vtkParam + "Colors";
5833 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5836 QStringList sizeStr;
5838 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5839 sizeStr << "outline";
5840 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5841 sizeStr << "elem0d";
5842 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5844 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5845 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5846 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5847 sizeStr << "shrink";
5848 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5849 sizeStr << "orientation";
5850 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5851 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5853 param = vtkParam + "Sizes";
5854 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5859 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5860 if( aMarkerType == VTK::MT_USER ) {
5861 markerStr += "custom";
5862 markerStr += gDigitsSep;
5863 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5867 markerStr += gDigitsSep;
5868 markerStr += QString::number( (int)aMarkerType );
5869 markerStr += gDigitsSep;
5870 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5873 param = vtkParam + "PointMarker";
5874 ip->setParameter(entry, param, markerStr.toLatin1().data());
5877 param = vtkParam + "Opacity";
5878 ip->setParameter(entry, param,
5879 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5882 param = vtkParam + "ClippingPlane";
5884 if( !aClippingPlaneInfoList.empty() ) {
5885 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5886 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5888 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5889 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5890 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5891 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5892 if( aSmeshActor == *anIter2 ) {
5893 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5894 QString::number( anId ).toLatin1().constData() );
5901 ip->setParameter( entry, param, "Off" );
5902 } // if (io->hasEntry())
5903 } // SMESH_Actor && hasIO
5905 } // while.. actors traversal
5909 } // if (SVTK view model)
5910 } // for (viewManagers)
5913 // data structures for clipping planes processing
5917 bool isOpenGLClipping;
5918 vtkIdType RelativeOrientation;
5921 int AbsoluteOrientation;
5922 double X, Y, Z, Dx, Dy, Dz;
5924 typedef std::list<TPlaneData> TPlaneDataList;
5925 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5927 typedef std::list<vtkActor*> TActorList;
5930 TActorList ActorList;
5931 SUIT_ViewManager* ViewManager;
5933 typedef std::list<TPlaneInfo> TPlaneInfoList;
5934 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5937 * \brief Restore visual parameters
5939 * This method is called after the study document is opened.
5940 * Restore visual parameters from AttributeParameter attribue(s)
5942 void SMESHGUI::restoreVisualParameters (int savePoint)
5945 Kernel_Utils::Localizer loc;
5947 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5948 if (!appStudy || !appStudy->studyDS())
5950 _PTR(Study) studyDS = appStudy->studyDS();
5952 // componentName is used for encoding of entries when storing them in IParameters
5953 std::string componentName = myComponentSMESH->ComponentDataType();
5954 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5955 //if (!aSComponent) return;
5958 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5959 componentName.c_str(),
5961 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5963 // restore map of custom markers and map of clipping planes
5964 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5965 TPlaneDataMap aPlaneDataMap;
5967 std::vector<std::string> properties = ip->getProperties();
5968 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5970 std::string property = *propIt;
5971 QString aPropertyName( property.c_str() );
5972 QString aPropertyValue( ip->getProperty( property ).c_str() );
5974 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5975 if( aPropertyNameList.isEmpty() )
5978 QString aPropertyType = aPropertyNameList[0];
5979 if( aPropertyType == "texture" )
5981 if( aPropertyNameList.size() != 2 )
5985 int anId = aPropertyNameList[1].toInt( &ok );
5986 if( !ok || anId < 1 )
5989 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5990 if( aPropertyValueList.size() != 2 )
5993 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5994 QString aMarkerTextureString = aPropertyValueList[1];
5995 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5996 if( aMarkerTextureStringList.size() != 3 )
6000 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6005 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6009 VTK::MarkerTexture aMarkerTexture;
6010 aMarkerTexture.push_back( aWidth );
6011 aMarkerTexture.push_back( aHeight );
6013 QString aMarkerTextureData = aMarkerTextureStringList[2];
6014 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6016 QChar aChar = aMarkerTextureData.at( i );
6017 if( aChar.isDigit() )
6018 aMarkerTexture.push_back( aChar.digitValue() );
6021 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6023 else if( aPropertyType == "ClippingPlane" )
6025 if( aPropertyNameList.size() != 3 )
6029 int aViewId = aPropertyNameList[1].toInt( &ok );
6030 if( !ok || aViewId < 0 )
6034 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6035 if( !ok || aClippingPlaneId < 0 )
6038 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6039 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6042 TPlaneData aPlaneData;
6043 aPlaneData.Id = aClippingPlaneId;
6046 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6051 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6055 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6058 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6063 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6068 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6073 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6078 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6083 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6088 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6092 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6094 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6099 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6104 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6109 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6114 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6115 aPlaneDataList.push_back( aPlaneData );
6119 TPlaneInfoMap aPlaneInfoMap;
6121 std::vector<std::string> entries = ip->getEntries();
6123 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6125 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6126 QString entry (ip->decodeEntry(*entIt).c_str());
6128 // Check that the entry corresponds to a real object in the Study
6129 // as the object may be deleted or modified after the visual state is saved.
6130 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6131 if (!so) continue; //Skip the not existent entry
6133 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6134 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6136 std::vector<std::string>::iterator namesIt = paramNames.begin();
6137 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6139 // actors are stored in a map after displaying of them for
6140 // quicker access in the future: map < viewID to actor >
6141 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6143 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6145 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6146 // '_' is used as separator and should not be used in viewer type or parameter names.
6147 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6148 if (lst.size() != 3)
6151 QString viewerTypStr = lst[0];
6152 QString viewIndexStr = lst[1];
6153 QString paramNameStr = lst[2];
6156 int viewIndex = viewIndexStr.toUInt(&ok);
6157 if (!ok) // bad conversion of view index to integer
6161 if (viewerTypStr == SVTK_Viewer::Type())
6163 SMESH_Actor* aSmeshActor = 0;
6164 if (vtkActors.IsBound(viewIndex))
6165 aSmeshActor = vtkActors.Find(viewIndex);
6167 QList<SUIT_ViewManager*> lst;
6168 getApp()->viewManagers(viewerTypStr, lst);
6170 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6171 SUIT_ViewManager* vman = NULL;
6172 if (viewIndex >= 0 && viewIndex < lst.count())
6173 vman = lst.at(viewIndex);
6175 if (paramNameStr == "Visibility")
6177 if (!aSmeshActor && displayer() && vman)
6179 SUIT_ViewModel* vmodel = vman->getViewModel();
6180 // SVTK view model can be casted to SALOME_View
6181 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6183 // store displayed actor in a temporary map for quicker
6184 // access later when restoring other parameters
6185 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6186 vtkRenderer* Renderer = vtkView->getRenderer();
6187 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6188 vtkActorCollection* theActors = aCopy.GetActors();
6189 theActors->InitTraversal();
6190 bool isFound = false;
6191 vtkActor *ac = theActors->GetNextActor();
6192 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6193 if (ac->IsA("SMESH_Actor")) {
6194 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6195 if (aGeomAc->hasIO()) {
6196 Handle(SALOME_InteractiveObject) io =
6197 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6198 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6200 vtkActors.Bind(viewIndex, aGeomAc);
6206 } // if (paramNameStr == "Visibility")
6209 // the rest properties "work" with SMESH_Actor
6212 QString val ((*valuesIt).c_str());
6215 if (paramNameStr == "Representation") {
6216 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6219 else if (paramNameStr == "IsShrunk") {
6221 if (!aSmeshActor->IsShrunk())
6222 aSmeshActor->SetShrink();
6225 if (aSmeshActor->IsShrunk())
6226 aSmeshActor->UnShrink();
6229 // Displayed entities
6230 else if (paramNameStr == "Entities") {
6231 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6232 int aEntityMode = SMESH_Actor::eAllEntity;
6233 for ( int i = 0; i < mode.count(); i+=2 ) {
6234 if ( i < mode.count()-1 ) {
6235 QString type = mode[i];
6236 bool val = mode[i+1].toInt();
6237 if ( type == "e" && !val )
6238 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6239 else if ( type == "f" && !val )
6240 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6241 else if ( type == "v" && !val )
6242 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6243 else if ( type == "0d" && !val )
6244 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6245 else if ( type == "b" && !val )
6246 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6249 aSmeshActor->SetEntityMode( aEntityMode );
6252 else if (paramNameStr == "Colors") {
6253 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6260 QColor outlineColor;
6261 QColor orientationColor;
6267 // below lines are required to get default values for delta coefficients
6268 // of backface color for faces and color of reversed volumes
6269 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6270 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6271 for ( int i = 0; i < colors.count(); i++ ) {
6272 QString type = colors[i];
6273 if ( type == "surface" ) {
6274 // face color is set by 3 values r:g:b, where
6275 // - r,g,b - is rgb color components
6276 if ( i+1 >= colors.count() ) break; // format error
6277 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6278 if ( i+2 >= colors.count() ) break; // format error
6279 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6280 if ( i+3 >= colors.count() ) break; // format error
6281 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6282 faceColor.setRgbF( r, g, b );
6285 else if ( type == "backsurface" ) {
6286 // backface color can be defined in several ways
6287 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6288 // - in latest versions, it is set as delta coefficient
6289 bool rgbOk = false, deltaOk;
6290 if ( i+1 >= colors.count() ) break; // format error
6291 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6292 int delta = colors[i+1].toInt( &deltaOk );
6294 if ( i+1 < colors.count() ) // index is shifted to 1
6295 g = colors[i+1].toDouble( &rgbOk );
6296 if ( rgbOk ) i++; // shift index
6297 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6298 b = colors[i+1].toDouble( &rgbOk );
6300 // - as currently there's no way to set directly backsurface color as it was before,
6301 // we ignore old dump where r,g,b triple was set
6302 // - also we check that delta parameter is set properly
6303 if ( !rgbOk && deltaOk )
6306 else if ( type == "volume" ) {
6307 // volume color is set by 4 values r:g:b:delta, where
6308 // - r,g,b - is a normal volume rgb color components
6309 // - delta - is a reversed volume color delta coefficient
6310 if ( i+1 >= colors.count() ) break; // format error
6311 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6312 if ( i+2 >= colors.count() ) break; // format error
6313 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6314 if ( i+3 >= colors.count() ) break; // format error
6315 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6316 if ( i+4 >= colors.count() ) break; // format error
6317 int delta = colors[i+4].toInt( &bOk );
6318 if ( !bOk ) break; // format error
6319 volumeColor.setRgbF( r, g, b );
6323 else if ( type == "edge" ) {
6324 // edge color is set by 3 values r:g:b, where
6325 // - r,g,b - is rgb color components
6326 if ( i+1 >= colors.count() ) break; // format error
6327 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6328 if ( i+2 >= colors.count() ) break; // format error
6329 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6330 if ( i+3 >= colors.count() ) break; // format error
6331 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6332 edgeColor.setRgbF( r, g, b );
6335 else if ( type == "node" ) {
6336 // node color is set by 3 values r:g:b, where
6337 // - r,g,b - is rgb color components
6338 if ( i+1 >= colors.count() ) break; // format error
6339 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6340 if ( i+2 >= colors.count() ) break; // format error
6341 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6342 if ( i+3 >= colors.count() ) break; // format error
6343 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6344 nodeColor.setRgbF( r, g, b );
6347 else if ( type == "elem0d" ) {
6348 // 0d element color is set by 3 values r:g:b, where
6349 // - r,g,b - is rgb color components
6350 if ( i+1 >= colors.count() ) break; // format error
6351 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6352 if ( i+2 >= colors.count() ) break; // format error
6353 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6354 if ( i+3 >= colors.count() ) break; // format error
6355 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6356 elem0dColor.setRgbF( r, g, b );
6359 else if ( type == "ball" ) {
6360 // ball color is set by 3 values r:g:b, where
6361 // - r,g,b - is rgb color components
6362 if ( i+1 >= colors.count() ) break; // format error
6363 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6364 if ( i+2 >= colors.count() ) break; // format error
6365 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6366 if ( i+3 >= colors.count() ) break; // format error
6367 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6368 ballColor.setRgbF( r, g, b );
6371 else if ( type == "outline" ) {
6372 // outline color is set by 3 values r:g:b, where
6373 // - r,g,b - is rgb color components
6374 if ( i+1 >= colors.count() ) break; // format error
6375 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6376 if ( i+2 >= colors.count() ) break; // format error
6377 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6378 if ( i+3 >= colors.count() ) break; // format error
6379 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6380 outlineColor.setRgbF( r, g, b );
6383 else if ( type == "orientation" ) {
6384 // orientation color is set by 3 values r:g:b, where
6385 // - r,g,b - is rgb color components
6386 if ( i+1 >= colors.count() ) break; // format error
6387 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6388 if ( i+2 >= colors.count() ) break; // format error
6389 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6390 if ( i+3 >= colors.count() ) break; // format error
6391 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6392 orientationColor.setRgbF( r, g, b );
6397 if ( nodeColor.isValid() )
6398 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6400 if ( edgeColor.isValid() )
6401 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6403 if ( faceColor.isValid() )
6404 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6406 if ( volumeColor.isValid() )
6407 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6408 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6409 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6411 if ( elem0dColor.isValid() )
6412 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6414 if ( ballColor.isValid() )
6415 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6417 if ( outlineColor.isValid() )
6418 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6419 // orientation color
6420 if ( orientationColor.isValid() )
6421 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6424 else if (paramNameStr == "Sizes") {
6425 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6428 int outlineWidth = -1;
6429 int elem0dSize = -1;
6430 //int ballSize = -1;
6431 double ballDiameter = -1.0;
6432 double ballScale = -1.0;
6433 double shrinkSize = -1;
6434 double orientationSize = -1;
6435 bool orientation3d = false;
6436 for ( int i = 0; i < sizes.count(); i++ ) {
6437 QString type = sizes[i];
6438 if ( type == "line" ) {
6439 // line (wireframe) width is given as single integer value
6440 if ( i+1 >= sizes.count() ) break; // format error
6441 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6445 if ( type == "outline" ) {
6446 // outline width is given as single integer value
6447 if ( i+1 >= sizes.count() ) break; // format error
6448 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6452 else if ( type == "elem0d" ) {
6453 // 0d element size is given as single integer value
6454 if ( i+1 >= sizes.count() ) break; // format error
6455 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6459 else if ( type == "ball" ) {
6460 // balls are specified by two values: size:scale, where
6461 // - size - is a integer value specifying size
6462 // - scale - is a double value specifying scale factor
6463 if ( i+1 >= sizes.count() ) break; // format error
6464 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6465 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6466 if ( i+2 >= sizes.count() ) break; // format error
6467 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 else if ( type == "shrink" ) {
6474 // shrink factor is given as single floating point value
6475 if ( i+1 >= sizes.count() ) break; // format error
6476 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6480 else if ( type == "orientation" ) {
6481 // orientation vectors are specified by two values size:3d, where
6482 // - size - is a floating point value specifying scale factor
6483 // - 3d - is a boolean
6484 if ( i+1 >= sizes.count() ) break; // format error
6485 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6486 if ( i+2 >= sizes.count() ) break; // format error
6487 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6488 orientationSize = v1;
6489 orientation3d = (bool)v2;
6493 // line (wireframe) width
6494 if ( lineWidth > 0 )
6495 aSmeshActor->SetLineWidth( lineWidth );
6497 if ( outlineWidth > 0 )
6498 aSmeshActor->SetOutlineWidth( outlineWidth );
6499 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6500 aSmeshActor->SetOutlineWidth( lineWidth );
6502 if ( elem0dSize > 0 )
6503 aSmeshActor->Set0DSize( elem0dSize );
6505 /*if ( ballSize > 0 )
6506 aSmeshActor->SetBallSize( ballSize );*/
6508 if ( ballDiameter > 0 )
6509 aSmeshActor->SetBallSize( ballDiameter );
6511 if ( ballScale > 0.0 )
6512 aSmeshActor->SetBallScale( ballScale );
6514 if ( shrinkSize > 0 )
6515 aSmeshActor->SetShrinkFactor( shrinkSize );
6516 // orientation vectors
6517 if ( orientationSize > 0 ) {
6518 aSmeshActor->SetFacesOrientationScale( orientationSize );
6519 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6523 else if (paramNameStr == "PointMarker") {
6524 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6525 if( data.count() >= 2 ) {
6527 int aParam1 = data[1].toInt( &ok );
6529 if( data[0] == "std" && data.count() == 3 ) {
6530 int aParam2 = data[2].toInt( &ok );
6531 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6533 else if( data[0] == "custom" ) {
6534 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6535 if( markerIt != aMarkerMap.end() ) {
6536 VTK::MarkerData aMarkerData = markerIt->second;
6537 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6544 else if (paramNameStr == "Opacity") {
6545 aSmeshActor->SetOpacity(val.toFloat());
6548 else if (paramNameStr.startsWith("ClippingPlane")) {
6549 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6550 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6551 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6552 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6553 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6554 // new format - val looks like "Off" or "0" (plane id)
6555 // (note: in new format "Off" value is used only for consistency,
6556 // so it is processed together with values in old format)
6557 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6558 if( anIsOldFormat ) {
6559 if (paramNameStr == "ClippingPlane1" || val == "Off")
6560 aSmeshActor->RemoveAllClippingPlanes();
6562 QList<SUIT_ViewManager*> lst;
6563 getApp()->viewManagers(viewerTypStr, lst);
6564 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6565 if (viewIndex >= 0 && viewIndex < lst.count()) {
6566 SUIT_ViewManager* vman = lst.at(viewIndex);
6567 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6569 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6571 SMESH::TActorList anActorList;
6572 anActorList.push_back( aSmeshActor );
6573 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6574 aPlane->myViewWindow = vtkView;
6575 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6576 aPlane->PlaneMode = aMode;
6577 bool isOpenGLClipping = ( bool )vals[1].toInt();
6578 aPlane->IsOpenGLClipping = isOpenGLClipping;
6579 if ( aMode == SMESH::Absolute ) {
6580 aPlane->myAbsoluteOrientation = vals[2].toInt();
6581 aPlane->X = vals[3].toFloat();
6582 aPlane->Y = vals[4].toFloat();
6583 aPlane->Z = vals[5].toFloat();
6584 aPlane->Dx = vals[6].toFloat();
6585 aPlane->Dy = vals[7].toFloat();
6586 aPlane->Dz = vals[8].toFloat();
6588 else if ( aMode == SMESH::Relative ) {
6589 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6590 aPlane->myDistance = vals[3].toFloat();
6591 aPlane->myAngle[0] = vals[4].toFloat();
6592 aPlane->myAngle[1] = vals[5].toFloat();
6596 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6597 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6598 aClippingPlaneInfo.Plane = aPlane;
6599 aClippingPlaneInfo.ActorList = anActorList;
6600 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6608 int aPlaneId = val.toInt( &ok );
6609 if( ok && aPlaneId >= 0 ) {
6610 bool anIsDefinedPlane = false;
6611 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6612 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6613 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6614 TPlaneInfo& aPlaneInfo = *anIter;
6615 if( aPlaneInfo.PlaneId == aPlaneId ) {
6616 aPlaneInfo.ActorList.push_back( aSmeshActor );
6617 anIsDefinedPlane = true;
6621 if( !anIsDefinedPlane ) {
6622 TPlaneInfo aPlaneInfo;
6623 aPlaneInfo.PlaneId = aPlaneId;
6624 aPlaneInfo.ActorList.push_back( aSmeshActor );
6625 aPlaneInfo.ViewManager = vman;
6627 // to make the list sorted by plane id
6628 anIter = aPlaneInfoList.begin();
6629 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6630 const TPlaneInfo& aPlaneInfoRef = *anIter;
6631 if( aPlaneInfoRef.PlaneId > aPlaneId )
6634 aPlaneInfoList.insert( anIter, aPlaneInfo );
6639 } // if (aSmeshActor)
6640 } // other parameters than Visibility
6642 } // for names/parameters iterator
6643 } // for entries iterator
6645 // take into account planes with empty list of actors referred to them
6646 QList<SUIT_ViewManager*> aVMList;
6647 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6649 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6650 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6651 int aViewId = aPlaneDataIter->first;
6652 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6653 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6655 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6657 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6658 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6659 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6660 const TPlaneData& aPlaneData = *anIter2;
6661 int aPlaneId = aPlaneData.Id;
6663 bool anIsFound = false;
6664 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6665 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6666 const TPlaneInfo& aPlaneInfo = *anIter3;
6667 if( aPlaneInfo.PlaneId == aPlaneId ) {
6674 TPlaneInfo aPlaneInfo; // ActorList field is empty
6675 aPlaneInfo.PlaneId = aPlaneId;
6676 aPlaneInfo.ViewManager = aViewManager;
6678 // to make the list sorted by plane id
6679 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6680 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6681 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6682 if( aPlaneInfoRef.PlaneId > aPlaneId )
6685 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6691 // add clipping planes to actors according to the restored parameters
6692 // and update the clipping plane map
6693 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6694 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6695 int aViewId = anIter1->first;
6696 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6698 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6699 if( anIter2 == aPlaneDataMap.end() )
6701 const TPlaneDataList& aPlaneDataList = anIter2->second;
6703 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6704 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6705 const TPlaneInfo& aPlaneInfo = *anIter3;
6706 int aPlaneId = aPlaneInfo.PlaneId;
6707 const TActorList& anActorList = aPlaneInfo.ActorList;
6708 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6712 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6716 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6718 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6719 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6720 const TPlaneData& aPlaneData = *anIter4;
6721 if( aPlaneData.Id == aPlaneId ) {
6722 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6723 aPlane->myViewWindow = aViewWindow;
6724 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6725 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6726 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6727 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6728 aPlane->X = aPlaneData.X;
6729 aPlane->Y = aPlaneData.Y;
6730 aPlane->Z = aPlaneData.Z;
6731 aPlane->Dx = aPlaneData.Dx;
6732 aPlane->Dy = aPlaneData.Dy;
6733 aPlane->Dz = aPlaneData.Dz;
6735 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6736 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6737 aPlane->myDistance = aPlaneData.Distance;
6738 aPlane->myAngle[0] = aPlaneData.Angle[0];
6739 aPlane->myAngle[1] = aPlaneData.Angle[1];
6742 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6743 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6744 aClippingPlaneInfo.Plane = aPlane;
6745 aClippingPlaneInfo.ActorList = anActorList;
6746 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6757 // update all VTK views
6758 QList<SUIT_ViewManager*> lst;
6759 getApp()->viewManagers(lst);
6760 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6761 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6762 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6763 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6764 // set OpenGL clipping planes
6765 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6766 vtkActorCollection* anAllActors = aCopy.GetActors();
6767 anAllActors->InitTraversal();
6768 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6769 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6770 anActor->SetOpenGLClippingPlane();
6772 vtkView->getRenderer()->ResetCameraClippingRange();
6779 \brief Adds preferences for dfont of VTK viewer
6781 \param pIf group identifier
6782 \param param parameter
6783 \return identifier of preferences
6785 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6787 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6789 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6792 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6793 fam.append( tr( "SMESH_FONT_COURIER" ) );
6794 fam.append( tr( "SMESH_FONT_TIMES" ) );
6796 setPreferenceProperty( tfont, "fonts", fam );
6798 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6799 if ( needSize ) f = f | QtxFontEdit::Size;
6800 setPreferenceProperty( tfont, "features", f );
6806 \brief Actions after hypothesis edition
6807 Updates object browser after hypothesis edition
6809 void SMESHGUI::onHypothesisEdit( int result )
6812 SMESHGUI::Modified();
6813 updateObjBrowser( true );
6818 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6819 \param pview view being closed
6821 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6822 #ifndef DISABLE_PLOT2DVIEWER
6823 //Crear all Plot2d Viewers if need.
6824 SMESH::ClearPlot2Viewers(pview);
6828 void SMESHGUI::message( const QString& msg )
6831 QStringList data = msg.split("/");
6832 if ( data.count() > 0 ) {
6833 if ( data.first() == "mesh_loading" ) {
6835 QString entry = data.count() > 1 ? data[1] : QString();
6836 if ( entry.isEmpty() )
6839 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6841 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6844 name = SMESH::fromUtf8(obj->GetName());
6845 if ( name.isEmpty() )
6848 if ( data.last() == "stop" )
6849 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6851 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6852 QApplication::processEvents();
6858 \brief Connects or disconnects signals about activating and cloning view on the module slots
6859 \param pview view which is connected/disconnected
6861 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6865 SUIT_ViewManager* viewMgr = pview->getViewManager();
6867 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6868 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6870 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6871 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6876 \brief Return \c true if object can be renamed
6878 bool SMESHGUI::renameAllowed( const QString& entry) const {
6879 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6883 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6887 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6892 if(appStudy->isComponent(entry) || obj->isReference())
6895 // check type to prevent renaming of inappropriate objects
6896 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6897 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6898 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6899 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6900 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6901 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6908 Rename object by entry.
6909 \param entry entry of the object
6910 \param name new name of the object
6911 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6913 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6915 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6919 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6924 _PTR(Study) aStudy = appStudy->studyDS();
6929 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6931 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6936 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6937 _PTR(GenericAttribute) anAttr;
6938 _PTR(AttributeName) aName;
6940 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6942 // check type to prevent renaming of inappropriate objects
6943 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6944 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6945 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6946 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6947 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6948 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6949 if ( !name.isEmpty() ) {
6950 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6952 // update name of group object and its actor
6953 Handle(SALOME_InteractiveObject) IObject =
6954 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6956 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6957 if( !aGroupObject->_is_nil() ) {
6958 aGroupObject->SetName( qPrintable(name) );
6959 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6960 anActor->setName( qPrintable(name) );
6970 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6972 static QList<QColor> colors;
6974 if ( colors.isEmpty() ) {
6976 for (int s = 0; s < 2 ; s++)
6978 for (int v = 100; v >= 40; v = v - 20)
6980 for (int h = 0; h < 359 ; h = h + 60)
6982 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6987 static int currentColor = randomize( colors.size() );
6989 SALOMEDS::Color color;
6990 color.R = (double)colors[currentColor].red() / 255.0;
6991 color.G = (double)colors[currentColor].green() / 255.0;
6992 color.B = (double)colors[currentColor].blue() / 255.0;
6994 currentColor = (currentColor+1) % colors.count();