1 // Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
86 #include "SMESHGUI_FilterUtils.h"
87 #include "SMESHGUI_GEOMGenUtils.h"
88 #include "SMESHGUI_GroupUtils.h"
89 #include "SMESHGUI_HypothesesUtils.h"
90 #include "SMESHGUI_MeshUtils.h"
91 #include "SMESHGUI_PatternUtils.h"
92 #include "SMESHGUI_Utils.h"
93 #include "SMESHGUI_VTKUtils.h"
95 #include "SMESH_version.h"
97 #include "SMESH_ControlsDef.hxx"
98 #include "SMESH_Actor.h"
99 #include "SMESH_ActorUtils.h"
100 #include "SMESH_Client.hxx"
101 #include "SMESH_ScalarBarActor.h"
102 #include "SMESH_TypeFilter.hxx"
104 // SALOME GUI includes
105 #include <SalomeApp_Application.h>
106 #include <SalomeApp_CheckFileDlg.h>
107 #include <SalomeApp_DataObject.h>
108 #include <SalomeApp_Study.h>
109 #include <SalomeApp_Tools.h>
111 #include <LightApp_DataOwner.h>
112 #include <LightApp_NameDlg.h>
113 #include <LightApp_Preferences.h>
114 #include <LightApp_SelectionMgr.h>
115 #include <LightApp_UpdateFlags.h>
117 #include <SVTK_ViewManager.h>
118 #include <SVTK_ViewModel.h>
119 #include <SVTK_ViewWindow.h>
121 #include <VTKViewer_Algorithm.h>
123 #include <PyInterp_Interp.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
157 #include <boost/shared_ptr.hpp>
160 #include <vtkCallbackCommand.h>
161 #include <vtkCamera.h>
162 #include <vtkLookupTable.h>
163 #include <vtkPlane.h>
164 #include <vtkRenderer.h>
166 // SALOME KERNEL includes
167 #include <SALOMEDSClient_ClientFactory.hxx>
168 #include <SALOMEDSClient_IParameters.hxx>
169 #include <SALOMEDSClient_SComponent.hxx>
170 #include <SALOMEDSClient_StudyBuilder.hxx>
171 #include <SALOMEDS_Study.hxx>
172 #include <SALOMEDS_SObject.hxx>
173 #include "utilities.h"
176 #include <Standard_ErrorHandler.hxx>
177 #include <NCollection_DataMap.hxx>
179 #include <Basics_Utils.hxx>
181 //To disable automatic genericobj management, the following line should be commented.
182 //Otherwise, it should be uncommented.
183 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
184 #define WITHGENERICOBJ
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ) {
219 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
220 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
222 else if ( theCommandID == SMESHOp::OpImportUNV ) {
223 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
225 else if ( theCommandID == SMESHOp::OpImportDAT ) {
226 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
228 else if ( theCommandID == SMESHOp::OpImportSTL ) {
229 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
232 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
233 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
236 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
237 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
238 filter.append( QObject::tr( "All files (*)" ) );
240 else if ( theCommandID == SMESHOp::OpImportGMF ) {
241 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
242 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
245 QString anInitialPath = "";
246 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
247 anInitialPath = QDir::currentPath();
249 QStringList filenames;
250 bool toCreateGroups = true;
252 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
253 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
254 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
255 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
256 // fd->setNameFilters( filter );
257 // fd->SetChecked( true );
259 // filenames << fd->selectedFile();
260 // toCreateGroups = fd->IsChecked();
266 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
269 QObject::tr( "SMESH_IMPORT_MESH" ) );
271 if ( filenames.count() > 0 ) {
272 SUIT_OverrideCursor wc;
273 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
276 QStringList anEntryList;
277 bool isEmpty = false;
278 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
279 QString filename = *it;
280 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
282 switch ( theCommandID ) {
283 case SMESHOp::OpImportDAT:
285 // DAT format (currently unsupported)
286 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
287 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
290 case SMESHOp::OpImportUNV:
293 aMeshes->length( 1 );
294 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
295 if ( aMeshes[0]->_is_nil() )
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
300 case SMESHOp::OpImportMED:
303 SMESH::DriverMED_ReadStatus res;
304 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
305 if ( res != SMESH::DRS_OK ) {
306 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
307 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
311 case SMESHOp::OpImportSTL:
314 aMeshes->length( 1 );
315 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
316 if ( aMeshes[0]->_is_nil() ) {
317 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
318 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
323 case SMESHOp::OpImportCGNS:
326 SMESH::DriverMED_ReadStatus res;
327 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
328 if ( res != SMESH::DRS_OK ) {
329 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
330 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
335 case SMESHOp::OpImportSAUV:
338 SMESH::DriverMED_ReadStatus res;
339 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
340 if ( res != SMESH::DRS_OK ) {
341 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
342 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
346 case SMESHOp::OpImportGMF:
349 SMESH::ComputeError_var res;
350 aMeshes->length( 1 );
351 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
354 if ( res->code != SMESH::DRS_OK ) {
355 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
356 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
357 if ( strlen( res->comment.in() ) > 0 ) {
358 errors.back() += ": ";
359 errors.back() += res->comment.in();
366 catch ( const SALOME::SALOME_Exception& S_ex ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
371 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
372 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
374 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
375 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
376 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
377 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
378 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
380 anEntryList.append( aMeshSO->GetID().c_str() );
388 // update Object browser
389 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
391 // browse to the published meshes
392 if( LightApp_Application* anApp =
393 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
394 anApp->browseObjects( anEntryList );
396 // show Error message box if there were errors
397 if ( errors.count() > 0 ) {
398 SUIT_MessageBox::critical( SMESHGUI::desktop(),
399 QObject::tr( "SMESH_ERROR" ),
400 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
403 // show warning message box, if some imported mesh is empty
405 SUIT_MessageBox::warning( SMESHGUI::desktop(),
406 QObject::tr( "SMESH_WRN_WARNING" ),
407 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
412 //================================================================================
414 * \brief Export selected meshes or groups into a file
416 //================================================================================
418 void ExportMeshToFile( int theCommandID )
420 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
421 SALOME_ListIO selected;
423 aSel->selectedObjects( selected );
425 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
426 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
427 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
428 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
430 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
432 const bool isCGNS= false;
434 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
435 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
437 // actually, the following condition can't be met (added for insurance)
438 if( selected.Extent() == 0 ||
439 ( selected.Extent() > 1 && !isMED && !isSTL ))
442 // get mesh object from selection and check duplication of their names
443 bool hasDuplicatedMeshNames = false;
444 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
445 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
446 SALOME_ListIteratorOfListIO It( selected );
447 for( ; It.More(); It.Next() )
449 Handle(SALOME_InteractiveObject) anIObject = It.Value();
450 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
451 if ( aMeshItem->_is_nil() ) {
452 SUIT_MessageBox::warning( SMESHGUI::desktop(),
453 QObject::tr( "SMESH_WRN_WARNING" ),
454 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
458 QString aMeshName = anIObject->getName();
460 // check for name duplications
461 if ( !hasDuplicatedMeshNames )
462 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
463 if( aMeshName == (*aMeshIter).second ) {
464 hasDuplicatedMeshNames = true;
469 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
472 if( hasDuplicatedMeshNames && isMED ) {
473 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
474 QObject::tr("SMESH_WRN_WARNING"),
475 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
476 QObject::tr("SMESH_BUT_YES"),
477 QObject::tr("SMESH_BUT_NO"), 0, 1);
482 aMeshIter = aMeshList.begin();
483 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
484 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
485 QString aMeshName = (*aMeshIter).second;
487 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
489 // check for equal group names within each mesh
490 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
491 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
492 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
493 int aRet = SUIT_MessageBox::warning
494 (SMESHGUI::desktop(),
495 QObject::tr("SMESH_WRN_WARNING"),
496 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
497 QObject::tr("SMESH_BUT_YES"),
498 QObject::tr("SMESH_BUT_NO"), 0, 1);
505 // Warn the user about presence of not supported elements
507 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
511 notSupportedElemTypes.push_back( SMESH::Entity_0D );
512 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
517 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
518 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
519 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
520 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
521 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
522 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
523 notSupportedElemTypes.push_back( SMESH::Entity_0D );
524 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
529 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
530 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
531 notSupportedElemTypes.push_back( SMESH::Entity_0D );
532 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
537 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
538 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
543 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
544 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
545 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
546 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
547 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
548 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
549 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
554 notSupportedElemTypes.push_back( SMESH::Entity_0D );
555 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
559 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
560 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
564 if ( ! notSupportedElemTypes.empty() )
566 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
567 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
568 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
569 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
571 if ( !presentNotSupported.empty() )
574 const char* typeMsg[SMESH::Entity_Last] = {
575 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
576 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
577 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
578 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
579 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
580 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
581 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
582 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
584 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
585 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
586 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
587 if ( iType != presentNotSupported.size() - 1 )
588 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
590 int aRet = SUIT_MessageBox::warning
591 (SMESHGUI::desktop(),
592 QObject::tr("SMESH_WRN_WARNING"),
593 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
594 QObject::tr("SMESH_BUT_YES"),
595 QObject::tr("SMESH_BUT_NO"), 0, 1);
600 // Get parameters of export operation
603 SMESH::MED_VERSION aFormat;
604 // Init the parameters with the default values
605 bool aIsASCII_STL = true;
606 bool toCreateGroups = false;
607 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
609 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
610 bool toOverwrite = true;
611 bool toFindOutDim = true;
613 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
614 QString anInitialPath = "";
615 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
616 anInitialPath = QDir::currentPath();
618 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
620 // Get a file name to write in and additional otions
621 if ( isUNV || isDAT || isGMF ) // Export w/o options
624 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
626 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
628 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
629 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
630 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
631 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
632 anInitialPath + QString("/") + aMeshName,
633 aFilter, aTitle, false);
635 else if ( isCGNS )// Export to CGNS
637 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
638 fd->setWindowTitle( aTitle );
639 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
640 if ( !anInitialPath.isEmpty() )
641 fd->setDirectory( anInitialPath );
642 fd->selectFile(aMeshName);
643 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
644 fd->setValidator( fv );
647 aFilename = fd->selectedFile();
648 toOverwrite = fv->isOverwrite();
652 else if ( isSTL ) // Export to STL
654 QMap<QString, int> aFilterMap;
655 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
656 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
659 QMap<QString, int>::const_iterator it = aFilterMap.begin();
660 for ( ; it != aFilterMap.end(); ++it )
661 filters.push_back( it.key() );
663 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
664 fd->setWindowTitle( aTitle );
665 fd->setNameFilters( filters );
666 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
667 if ( !anInitialPath.isEmpty() )
668 fd->setDirectory( anInitialPath );
669 fd->selectFile(aMeshName);
673 aFilename = fd->selectedFile();
674 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
679 else if ( isMED || isSAUV ) // Export to MED or SAUV
681 QMap<QString, SMESH::MED_VERSION> aFilterMap;
682 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
684 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
685 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
686 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
689 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
690 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
691 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
695 QString aDefaultFilter;
696 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
697 for ( ; it != aFilterMap.end(); ++it ) {
698 filters.push_back( it.key() );
699 if (it.value() == SMESH::MED_V2_2)
700 aDefaultFilter = it.key();
702 QStringList checkBoxes;
703 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
705 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
706 QList< QWidget* > wdgList;
707 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
708 wdgList.append( fieldSelWdg );
710 SalomeApp_CheckFileDlg* fd =
711 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
712 fd->setWindowTitle( aTitle );
713 fd->setNameFilters( filters );
714 fd->selectNameFilter( aDefaultFilter );
715 fd->SetChecked( toCreateGroups, 0 );
716 fd->SetChecked( toFindOutDim, 1 );
717 if ( !anInitialPath.isEmpty() )
718 fd->setDirectory( anInitialPath );
719 fd->selectFile(aMeshName);
722 QListView *lview = fd->findChild<QListView*>("listView");
724 lview->setMinimumHeight(200);
726 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
728 tview->setMinimumHeight(200);
731 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
732 fd->setValidator( fv );
737 aFilename = fd->selectedFile();
739 aFilename = QString::null;
742 aFormat = aFilterMap[fd->selectedNameFilter()];
743 toOverwrite = fv->isOverwrite();
745 if ( !aFilename.isEmpty() ) {
746 // med-2.1 does not support poly elements
747 if ( aFormat==SMESH::MED_V2_1 )
748 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
749 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
750 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
751 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
752 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
754 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
755 QObject::tr("SMESH_WRN_WARNING"),
756 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
757 QObject::tr("SMESH_BUT_YES"),
758 QObject::tr("SMESH_BUT_NO"), 0, 1);
766 // can't append to an existing using other format
767 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
768 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
769 if( !isVersionOk || aVersion != aFormat ) {
770 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
771 QObject::tr("SMESH_WRN_WARNING"),
772 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
773 QObject::tr("SMESH_BUT_YES"),
774 QObject::tr("SMESH_BUT_NO"), 0, 1);
781 QStringList aMeshNamesCollisionList;
782 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
783 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
784 QString anExistingMeshName( aMeshNames[ i ] );
785 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
786 QString anExportMeshName = (*aMeshIter).second;
787 if( anExportMeshName == anExistingMeshName ) {
788 aMeshNamesCollisionList.append( anExportMeshName );
793 if( !aMeshNamesCollisionList.isEmpty() ) {
794 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
795 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
796 QObject::tr("SMESH_WRN_WARNING"),
797 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
798 QObject::tr("SMESH_BUT_YES"),
799 QObject::tr("SMESH_BUT_NO"),
800 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
809 toCreateGroups = fd->IsChecked(0);
810 toFindOutDim = fd->IsChecked(1);
811 fieldSelWdg->GetSelectedFeilds();
812 if ( !fieldSelWdg->parent() )
823 if ( !aFilename.isEmpty() ) {
824 // Check whether the file already exists and delete it if yes
825 QFile aFile( aFilename );
826 if ( aFile.exists() && toOverwrite )
828 SUIT_OverrideCursor wc;
831 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
832 // bool Renumber = false;
833 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
835 // Renumber= resMgr->booleanValue("renumbering");
837 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
838 // aMeshEditor->RenumberNodes();
839 // aMeshEditor->RenumberElements();
840 // if ( SMESHGUI::automaticUpdate() )
841 // SMESH::UpdateView();
845 aMeshIter = aMeshList.begin();
846 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
848 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
849 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
850 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
851 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
852 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
853 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
854 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
855 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
857 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
858 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
859 fields, geoAssFields.toLatin1().data() );
864 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
866 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
867 if( !aMeshItem->_is_nil() )
868 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
873 if ( aMeshOrGroup->_is_equivalent( aMesh ))
874 aMesh->ExportDAT( aFilename.toUtf8().data() );
876 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
880 if ( aMeshOrGroup->_is_equivalent( aMesh ))
881 aMesh->ExportUNV( aFilename.toUtf8().data() );
883 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
887 if ( aMeshOrGroup->_is_equivalent( aMesh ))
888 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
890 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
894 aMeshIter = aMeshList.begin();
895 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
897 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
898 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
899 aMeshItem->ExportCGNS( aMeshOrGroup,
900 aFilename.toUtf8().data(),
901 toOverwrite && aMeshIndex == 0 );
906 toCreateGroups = true;
907 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
910 catch (const SALOME::SALOME_Exception& S_ex){
912 SUIT_MessageBox::warning(SMESHGUI::desktop(),
913 QObject::tr("SMESH_WRN_WARNING"),
914 QObject::tr("SMESH_EXPORT_FAILED"));
920 inline void InverseEntityMode(unsigned int& theOutputMode,
921 unsigned int theMode)
923 bool anIsNotPresent = ~theOutputMode & theMode;
925 theOutputMode |= theMode;
927 theOutputMode &= ~theMode;
930 void SetDisplayEntity(int theCommandID){
931 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
932 SALOME_ListIO selected;
934 aSel->selectedObjects( selected );
936 if(selected.Extent() >= 1){
937 SALOME_ListIteratorOfListIO It( selected );
938 for( ; It.More(); It.Next()){
939 Handle(SALOME_InteractiveObject) IObject = It.Value();
940 if(IObject->hasEntry()){
941 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
942 unsigned int aMode = anActor->GetEntityMode();
943 switch(theCommandID){
944 case SMESHOp::OpDE0DElements:
945 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
947 case SMESHOp::OpDEEdges:
948 InverseEntityMode(aMode,SMESH_Actor::eEdges);
950 case SMESHOp::OpDEFaces:
951 InverseEntityMode(aMode,SMESH_Actor::eFaces);
953 case SMESHOp::OpDEVolumes:
954 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
956 case SMESHOp::OpDEBalls:
957 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
959 case SMESHOp::OpDEAllEntity:
960 aMode = SMESH_Actor::eAllEntity;
964 anActor->SetEntityMode(aMode);
973 SALOME_ListIO selected;
974 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
978 LightApp_SelectionMgr* aSel = app->selectionMgr();
979 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
980 if( !aSel || !appStudy )
983 aSel->selectedObjects( selected );
984 if( selected.IsEmpty() )
987 Handle(SALOME_InteractiveObject) anIObject = selected.First();
989 _PTR(Study) aStudy = appStudy->studyDS();
990 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
991 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
992 if( aMainObject->_is_nil() )
995 SUIT_OverrideCursor wc;
997 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
999 QList<SALOMEDS::Color> aReservedColors;
1001 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1002 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1004 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1005 //SALOMEDS::Color aColor = aGroupObject->GetColor();
1007 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1008 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1009 #else // old algorithm for auto-colors
1010 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1011 aReservedColors.append( aColor );
1012 #endif // SIMPLE_AUTOCOLOR
1013 aGroupObject->SetColor( aColor );
1015 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1016 if (aGroupSObject) {
1019 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1020 switch ( aGroupObject->GetType ()) {
1022 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1024 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1026 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1028 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1030 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1031 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1034 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1035 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1041 SMESH::RepaintCurrentView();
1044 void OverallMeshQuality() {
1045 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1046 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1047 SALOME_ListIO selected;
1049 aSel->selectedObjects( selected );
1051 if ( selected.IsEmpty() ) return;
1052 SALOME_ListIteratorOfListIO It( selected );
1053 for ( ; It.More(); It.Next() ) {
1054 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1055 ctrlDlg->showInfo( It.Value() );
1060 QString functorToString( SMESH::Controls::FunctorPtr f )
1062 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1063 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1064 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1065 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1066 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1067 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1068 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1069 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1070 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1071 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1072 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1073 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1074 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1075 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1076 type = QObject::tr( "WARP_ELEMENTS" );
1077 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1078 type = QObject::tr( "TAPER_ELEMENTS" );
1079 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1080 type = QObject::tr( "SKEW_ELEMENTS" );
1081 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1082 type = QObject::tr( "AREA_ELEMENTS" );
1083 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1084 type = QObject::tr( "LENGTH_EDGES" );
1085 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1086 type = QObject::tr( "LENGTH2D_EDGES" );
1087 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1088 type = QObject::tr( "MULTI_BORDERS" );
1089 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1090 type = QObject::tr( "MULTI2D_BORDERS" );
1091 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1092 type = QObject::tr( "FREE_NODES" );
1093 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1094 type = QObject::tr( "FREE_EDGES" );
1095 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1096 type = QObject::tr( "FREE_BORDERS" );
1097 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1098 type = QObject::tr( "FREE_FACES" );
1099 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1100 type = QObject::tr( "BARE_BORDER_VOLUME" );
1101 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1102 type = QObject::tr( "BARE_BORDER_FACE" );
1103 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1104 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1105 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1106 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1107 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1108 type = QObject::tr( "EQUAL_NODE" );
1109 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1110 type = QObject::tr( "EQUAL_EDGE" );
1111 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1112 type = QObject::tr( "EQUAL_FACE" );
1113 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1114 type = QObject::tr( "EQUAL_VOLUME" );
1118 void SaveDistribution()
1120 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1121 SALOME_ListIO selected;
1123 aSel->selectedObjects( selected );
1125 if ( selected.Extent() == 1 ) {
1126 Handle(SALOME_InteractiveObject) anIO = selected.First();
1127 if ( anIO->hasEntry() ) {
1128 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1129 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1130 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1131 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1132 if ( aScalarBarActor && aFunctor ) {
1133 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1135 std::vector<int> elements;
1136 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1137 if ( mesh->_is_nil() ) {
1138 SMESH::SMESH_IDSource_var idSource =
1139 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1140 if ( !idSource->_is_nil() )
1142 SMESH::long_array_var ids = idSource->GetIDs();
1143 elements.resize( ids->length() );
1144 for ( unsigned i = 0; i < elements.size(); ++i )
1145 elements[i] = ids[i];
1148 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1149 vtkLookupTable* lookupTable =
1150 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1151 double * minmax = lookupTable->GetRange();
1152 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1153 std::vector<int> nbEvents;
1154 std::vector<double> funValues;
1155 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1156 QString anInitialPath = "";
1157 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1158 anInitialPath = QDir::currentPath();
1159 QString aMeshName = anIO->getName();
1161 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1162 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1163 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1164 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1165 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1168 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1170 if ( !aFilename.isEmpty() ) {
1171 QFile f( aFilename );
1172 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1173 QTextStream out( &f );
1174 out << "# Mesh: " << aMeshName << endl;
1175 out << "# Control: " << functorToString( aFunctor ) << endl;
1177 out.setFieldWidth( 10 );
1178 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1179 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1190 void ShowDistribution() {
1191 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1192 SALOME_ListIO selected;
1194 aSel->selectedObjects( selected );
1196 if ( selected.Extent() == 1 ) {
1197 Handle(SALOME_InteractiveObject) anIO = selected.First();
1198 if ( anIO->hasEntry() ) {
1199 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1200 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1201 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1202 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1208 #ifndef DISABLE_PLOT2DVIEWER
1209 void PlotDistribution() {
1210 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1214 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1215 SALOME_ListIO selected;
1217 aSel->selectedObjects( selected );
1219 if ( selected.Extent() == 1 ) {
1220 Handle(SALOME_InteractiveObject) anIO = selected.First();
1221 if ( anIO->hasEntry() ) {
1222 //Find Actor by entry before getting Plot2d viewer,
1223 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1224 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1226 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1231 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1235 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1239 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1240 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1241 QString functorName = functorToString( anActor->GetFunctor());
1242 QString aHistogramName("%1 : %2");
1243 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1244 aHistogram->setName(aHistogramName);
1245 aHistogram->setHorTitle(functorName);
1246 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1247 aPlot->displayObject(aHistogram, true);
1252 #endif //DISABLE_PLOT2DVIEWER
1254 void DisableAutoColor(){
1255 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1256 SALOME_ListIO selected;
1258 aSel->selectedObjects( selected );
1260 if(selected.Extent()){
1261 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1262 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1263 if ( !aMesh->_is_nil() ) {
1264 aMesh->SetAutoColor( false );
1269 void sortChildren(){
1270 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1271 SALOME_ListIO selected;
1273 aSel->selectedObjects( selected );
1275 if(selected.Extent()){
1276 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1277 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1278 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1280 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1281 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1288 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1290 SALOME_ListIO selected;
1291 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1295 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1296 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1297 if( !aSel || !appStudy )
1300 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1301 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1302 aModule->EmitSignalDeactivateDialog();
1303 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1304 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1309 _PTR(Study) aStudy = appStudy->studyDS();
1311 aSel->selectedObjects( selected );
1313 if(selected.Extent() >= 1){
1314 switch(theCommandID){
1315 case SMESHOp::OpTransparency:{
1316 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1317 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1320 case SMESHOp::OpProperties: {
1322 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1323 QColor orientationColor, outlineColor, volumeColor;
1324 int deltaF = 0, deltaV = 0;
1327 double ballScale = 1.0;
1329 int outlineWidth = 1;
1330 double shrinkCoef = 0.0;
1331 double orientationScale = 0.0;
1332 bool orientation3d = false;
1333 VTK::MarkerType markerType = VTK::MT_NONE;
1334 VTK::MarkerScale markerScale = VTK::MS_NONE;
1336 bool hasNodes = false;
1337 int presentEntities = 0;
1338 bool firstTime = true;
1340 SALOME_ListIteratorOfListIO It( selected );
1341 for ( ; It.More(); It.Next() ) {
1342 Handle(SALOME_InteractiveObject) IObject = It.Value();
1343 if ( !IObject->hasEntry() ) continue;
1344 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1345 if ( !anActor || !anActor->GetObject() ) continue;
1348 // nodes: color, marker
1349 anActor->GetNodeColor( color[0], color[1], color[2] );
1350 nodeColor.setRgbF( color[0], color[1], color[2] );
1351 markerType = anActor->GetMarkerType();
1352 markerScale = anActor->GetMarkerScale();
1353 markerId = anActor->GetMarkerTexture();
1354 // edges: color, width
1355 anActor->GetEdgeColor( color[0], color[1], color[2] );
1356 edgeColor.setRgbF( color[0], color[1], color[2] );
1357 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1358 // faces: front color, back color (delta)
1359 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1360 faceColor.setRgbF( color[0], color[1], color[2] );
1361 // faces: front color, back color (delta)
1362 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1363 volumeColor.setRgbF( color[0], color[1], color[2] );
1364 // 0d elements: color, size
1365 anActor->Get0DColor( color[0], color[1], color[2] );
1366 elem0dColor.setRgbF( color[0], color[1], color[2] );
1367 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1368 // balls: color, size
1369 anActor->GetBallColor( color[0], color[1], color[2] );
1370 ballColor.setRgbF( color[0], color[1], color[2] );
1371 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1372 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1374 anActor->GetOutlineColor( color[0], color[1], color[2] );
1375 outlineColor.setRgbF( color[0], color[1], color[2] );
1376 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1377 // orientation vectors: color, scale, 3d flag
1378 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1379 orientationColor.setRgbF( color[0], color[1], color[2] );
1380 orientationScale = anActor->GetFacesOrientationScale();
1381 orientation3d = anActor->GetFacesOrientation3DVectors();
1383 shrinkCoef = anActor->GetShrinkFactor();
1386 firstTime = false; // we only take properties from first object (for performance reasons)
1389 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1390 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1391 presentEntities = presentEntities | SMESH_Actor::eEdges;
1392 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1393 presentEntities = presentEntities | SMESH_Actor::eFaces;
1394 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1395 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1396 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1397 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1398 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1399 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1401 // as we know that all types of elements are present, we can exit the loop
1402 if ( presentEntities == SMESH_Actor::eAllEntity )
1406 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1407 // nodes: color, marker
1408 dlg.setNodeColor( nodeColor );
1409 if( markerType != VTK::MT_USER )
1410 dlg.setNodeMarker( markerType, markerScale );
1412 dlg.setNodeCustomMarker( markerId );
1413 // edges: color, line width
1414 dlg.setEdgeColor( edgeColor );
1415 dlg.setEdgeWidth( edgeWidth );
1416 // faces: front color, back color
1417 dlg.setFaceColor( faceColor, deltaF );
1418 // volumes: normal color, reversed color
1419 dlg.setVolumeColor( volumeColor, deltaV );
1420 // outlines: color, line width
1421 dlg.setOutlineColor( outlineColor );
1422 dlg.setOutlineWidth( outlineWidth );
1423 // 0d elements: color, size
1424 dlg.setElem0dColor( elem0dColor );
1425 dlg.setElem0dSize( elem0dSize );
1426 // balls: color, size
1427 dlg.setBallColor( ballColor );
1428 dlg.setBallSize( ballSize );
1429 dlg.setBallScale( ballScale );
1430 // orientation: color, scale, 3d flag
1431 dlg.setOrientationColor( orientationColor );
1432 dlg.setOrientationSize( int( orientationScale * 100. ) );
1433 dlg.setOrientation3d( orientation3d );
1434 // shrink: scale factor
1435 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1436 // hide unused controls
1437 dlg.showControls( presentEntities, hasNodes );
1440 nodeColor = dlg.nodeColor();
1441 markerType = dlg.nodeMarkerType();
1442 markerScale = dlg.nodeMarkerScale();
1443 markerId = dlg.nodeMarkerId();
1444 edgeColor = dlg.edgeColor();
1445 edgeWidth = dlg.edgeWidth();
1446 faceColor = dlg.faceColor();
1447 deltaF = dlg.faceColorDelta();
1448 volumeColor = dlg.volumeColor();
1449 deltaV = dlg.volumeColorDelta();
1450 outlineColor = dlg.outlineColor();
1451 outlineWidth = dlg.outlineWidth();
1452 elem0dColor = dlg.elem0dColor();
1453 elem0dSize = dlg.elem0dSize();
1454 ballColor = dlg.ballColor();
1455 ballSize = dlg.ballSize();
1456 ballScale = dlg.ballScale();
1457 orientationColor = dlg.orientationColor();
1458 orientationScale = dlg.orientationSize() / 100.;
1459 orientation3d = dlg.orientation3d();
1460 shrinkCoef = dlg.shrinkCoef() / 100.;
1462 // store point markers map that might be changed by the user
1463 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1465 // set properties from dialog box to the presentations
1466 SALOME_ListIteratorOfListIO It( selected );
1467 for ( ; It.More(); It.Next() ) {
1468 Handle(SALOME_InteractiveObject) IObject = It.Value();
1469 if ( !IObject->hasEntry() ) continue;
1470 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1471 if ( !anActor ) continue;
1473 // nodes: color, marker
1474 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1475 if ( markerType != VTK::MT_USER ) {
1476 anActor->SetMarkerStd( markerType, markerScale );
1479 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1480 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1481 if ( iter != markerMap.end() )
1482 anActor->SetMarkerTexture( markerId, iter->second.second );
1484 // volumes: normal color, reversed color (delta)
1485 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1486 // faces: front color, back color (delta)
1487 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1488 // edges: color, width
1489 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1490 anActor->SetLineWidth( edgeWidth );
1492 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1493 anActor->SetOutlineWidth( outlineWidth );
1494 // 0D elements: color, size
1495 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1496 anActor->Set0DSize( elem0dSize );
1497 // balls: color, size
1498 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1499 anActor->SetBallSize( ballSize );
1500 anActor->SetBallScale( ballScale );
1501 // orientation: color, scale, 3d flag
1502 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1503 anActor->SetFacesOrientationScale( orientationScale );
1504 anActor->SetFacesOrientation3DVectors( orientation3d );
1506 anActor->SetShrinkFactor( shrinkCoef );
1508 // for groups, set also proper color
1509 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1510 if ( !aGroupObject->_is_nil() ) {
1511 SMESH::ElementType anElementType = aGroupObject->GetType();
1513 switch( anElementType ) {
1515 aColor = nodeColor; break;
1517 aColor = edgeColor; break;
1519 aColor = faceColor; break;
1521 aColor = volumeColor; break;
1523 aColor = elem0dColor; break;
1525 aColor = ballColor; break;
1529 if ( aColor.isValid() ) {
1530 SALOMEDS::Color aGroupColor;
1531 aGroupColor.R = aColor.redF();
1532 aGroupColor.G = aColor.greenF();
1533 aGroupColor.B = aColor.blueF();
1534 aGroupObject->SetColor( aGroupColor );
1536 } // if ( !aGroupObject->_is_nil() )
1537 } // for ( ; It.More(); It.Next() )
1538 SMESH::RepaintCurrentView();
1539 } // if ( dlg.exec() )
1541 } // case SMESHOp::OpProperties:
1542 } // switch(theCommandID)
1543 SALOME_ListIteratorOfListIO It( selected );
1544 for( ; It.More(); It.Next()){
1545 Handle(SALOME_InteractiveObject) IObject = It.Value();
1546 if(IObject->hasEntry()){
1547 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1548 switch(theCommandID){
1549 case SMESHOp::OpDMWireframe:
1550 anActor->SetRepresentation(SMESH_Actor::eEdge);
1552 case SMESHOp::OpDMShading:
1553 anActor->SetRepresentation(SMESH_Actor::eSurface);
1555 case SMESHOp::OpDMShrink:
1556 if(anActor->IsShrunk())
1557 anActor->UnShrink();
1559 anActor->SetShrink();
1561 case SMESHOp::OpDMNodes:
1562 anActor->SetRepresentation(SMESH_Actor::ePoint);
1564 case SMESHOp::OpRepresentationLines:
1565 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1566 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1568 case SMESHOp::OpRepresentationArcs:
1569 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1570 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1576 SMESH::RepaintCurrentView();
1580 void Control( int theCommandID )
1582 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1583 switch ( theCommandID ){
1584 case SMESHOp::OpFreeNode:
1585 aControl = SMESH_Actor::eFreeNodes;
1587 case SMESHOp::OpEqualNode:
1588 aControl = SMESH_Actor::eCoincidentNodes;
1590 case SMESHOp::OpFreeEdge:
1591 aControl = SMESH_Actor::eFreeEdges;
1593 case SMESHOp::OpFreeBorder:
1594 aControl = SMESH_Actor::eFreeBorders;
1596 case SMESHOp::OpLength:
1597 aControl = SMESH_Actor::eLength;
1599 case SMESHOp::OpConnection:
1600 aControl = SMESH_Actor::eMultiConnection;
1602 case SMESHOp::OpEqualEdge:
1603 aControl = SMESH_Actor::eCoincidentElems1D;
1605 case SMESHOp::OpFreeFace:
1606 aControl = SMESH_Actor::eFreeFaces;
1608 case SMESHOp::OpBareBorderFace:
1609 aControl = SMESH_Actor::eBareBorderFace;
1611 case SMESHOp::OpOverConstrainedFace:
1612 aControl = SMESH_Actor::eOverConstrainedFace;
1614 case SMESHOp::OpLength2D:
1615 aControl = SMESH_Actor::eLength2D;
1617 case SMESHOp::OpConnection2D:
1618 aControl = SMESH_Actor::eMultiConnection2D;
1620 case SMESHOp::OpArea:
1621 aControl = SMESH_Actor::eArea;
1623 case SMESHOp::OpTaper:
1624 aControl = SMESH_Actor::eTaper;
1626 case SMESHOp::OpAspectRatio:
1627 aControl = SMESH_Actor::eAspectRatio;
1629 case SMESHOp::OpMinimumAngle:
1630 aControl = SMESH_Actor::eMinimumAngle;
1632 case SMESHOp::OpWarpingAngle:
1633 aControl = SMESH_Actor::eWarping;
1635 case SMESHOp::OpSkew:
1636 aControl = SMESH_Actor::eSkew;
1638 case SMESHOp::OpMaxElementLength2D:
1639 aControl = SMESH_Actor::eMaxElementLength2D;
1641 case SMESHOp::OpEqualFace:
1642 aControl = SMESH_Actor:: eCoincidentElems2D;
1644 case SMESHOp::OpAspectRatio3D:
1645 aControl = SMESH_Actor::eAspectRatio3D;
1647 case SMESHOp::OpVolume:
1648 aControl = SMESH_Actor::eVolume3D;
1650 case SMESHOp::OpMaxElementLength3D:
1651 aControl = SMESH_Actor::eMaxElementLength3D;
1653 case SMESHOp::OpBareBorderVolume:
1654 aControl = SMESH_Actor::eBareBorderVolume;
1656 case SMESHOp::OpOverConstrainedVolume:
1657 aControl = SMESH_Actor::eOverConstrainedVolume;
1659 case SMESHOp::OpEqualVolume:
1660 aControl = SMESH_Actor::eCoincidentElems3D;
1663 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1664 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1665 SALOME_ListIO selected;
1667 aSel->selectedObjects( selected );
1669 if( !selected.IsEmpty() ){
1670 SALOME_ListIteratorOfListIO It(selected);
1671 for ( ; It.More(); It.Next())
1673 Handle(SALOME_InteractiveObject) anIO = It.Value();
1675 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1677 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1678 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1679 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1680 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1681 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1682 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1683 anActor->SetControlMode(aControl);
1684 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1685 SMESH::RepaintCurrentView();
1686 #ifndef DISABLE_PLOT2DVIEWER
1687 if(anActor->GetPlot2Histogram()) {
1688 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1689 QString functorName = functorToString( anActor->GetFunctor());
1690 QString aHistogramName("%1 : %2");
1691 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1692 aHistogram->setName(aHistogramName);
1693 aHistogram->setHorTitle(functorName);
1694 SMESH::ProcessIn2DViewers(anActor);
1706 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1707 SMESH::MeshObjectType theType,
1708 const QString theInTypeName,
1709 QString & theOutTypeName)
1711 SMESH_TypeFilter aTypeFilter( theType );
1713 if( !theIO.IsNull() )
1715 entry = theIO->getEntry();
1716 LightApp_DataOwner owner( entry );
1717 if ( aTypeFilter.isOk( &owner )) {
1718 theOutTypeName = theInTypeName;
1726 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1728 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1729 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1731 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1732 CORBA::String_var anID = aSComp->GetID().c_str();
1733 if (!strcmp(anID.in(),theIO->getEntry()))
1739 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1740 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1741 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1742 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1743 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1751 QString CheckHomogeneousSelection()
1753 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1754 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1755 SALOME_ListIO selected;
1757 aSel->selectedObjects( selected );
1759 QString RefType = CheckTypeObject(selected.First());
1760 SALOME_ListIteratorOfListIO It(selected);
1761 for ( ; It.More(); It.Next())
1763 Handle(SALOME_InteractiveObject) IObject = It.Value();
1764 QString Type = CheckTypeObject(IObject);
1765 if (Type.compare(RefType) != 0)
1766 return "Heterogeneous Selection";
1772 uint randomize( uint size )
1774 static bool initialized = false;
1775 if ( !initialized ) {
1776 qsrand( QDateTime::currentDateTime().toTime_t() );
1780 v = uint( (double)( v ) / RAND_MAX * size );
1781 v = qMax( uint(0), qMin ( v, size-1 ) );
1787 void SMESHGUI::OnEditDelete()
1789 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1790 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1791 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1793 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1794 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1795 _PTR(GenericAttribute) anAttr;
1796 _PTR(AttributeIOR) anIOR;
1798 int objectCount = 0;
1800 QString aParentComponent = QString::null;
1801 Handle(SALOME_InteractiveObject) anIO;
1802 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1804 anIO = anIt.Value();
1805 QString cur = anIO->getComponentDataType();
1806 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1808 // check if object is reference
1809 _PTR(SObject) aRefSObj;
1810 aNameList.append("\n - ");
1811 if ( aSO->ReferencedObject( aRefSObj ) ) {
1812 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1813 aNameList.append( aRefName );
1814 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1817 aNameList.append(anIO->getName());
1821 if( aParentComponent.isNull() )
1822 aParentComponent = cur;
1823 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1824 aParentComponent = "";
1827 if ( objectCount == 0 )
1828 return; // No Valid Objects Selected
1830 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1831 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1832 QObject::tr("ERR_ERROR"),
1833 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1836 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1837 if (SUIT_MessageBox::warning
1838 (SMESHGUI::desktop(),
1839 QObject::tr("SMESH_WRN_WARNING"),
1840 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1841 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1842 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1845 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1847 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1848 // then treat them all starting from the deepest objects (at list back)
1849 std::list< _PTR(SObject) > listSO;
1850 SALOME_ListIteratorOfListIO It(selected);
1851 for( ; It.More(); It.Next()) // loop on selected IO's
1853 Handle(SALOME_InteractiveObject) IObject = It.Value();
1854 if(IObject->hasEntry()) {
1855 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1857 // disable removal of "SMESH" component object
1858 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1860 if ( engineIOR() == anIOR->Value().c_str() )
1863 //Check the referenced object
1864 _PTR(SObject) aRefSObject;
1865 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1866 aSO = aRefSObject; // Delete main Object instead of reference
1868 listSO.push_back( aSO );
1869 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1870 for ( ; itSO != listSO.end(); ++itSO ) {
1871 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1872 for (it->InitEx(false); it->More(); it->Next())
1873 listSO.push_back( it->Value() );
1877 // Check if none of objects to delete is referred from outside
1878 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1879 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1881 _PTR(SObject) SO = *ritSO;
1882 if ( !SO ) continue;
1883 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1884 for (size_t i = 0; i < aReferences.size(); i++) {
1885 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1886 std::string type = aComponent->ComponentDataType();
1887 if ( type != "SMESH" )
1889 SUIT_MessageBox::warning( anApp->desktop(),
1890 QObject::tr("WRN_WARNING"),
1891 QObject::tr("DEP_OBJECT") );
1892 return; // outside SMESH, there is an object depending on a SMESH object
1897 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1898 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1900 Handle(SALOME_InteractiveObject) IObject = It.Value();
1901 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1902 if ( !mesh->_is_nil() )
1906 // Treat SO's in the list starting from the back
1907 aStudyBuilder->NewCommand(); // There is a transaction
1908 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1910 _PTR(SObject) SO = *ritSO;
1911 if ( !SO ) continue;
1912 std::string anEntry = SO->GetID();
1914 /** Erase graphical object and remove all its data **/
1915 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1916 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1918 /** Remove an object from data structures **/
1919 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1920 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1921 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1922 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1923 aMesh->RemoveGroup( aGroup );
1925 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1926 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1927 aMesh->RemoveSubMesh( aSubMesh );
1929 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1931 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1934 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1935 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1936 QString objType = CheckTypeObject(IObject);
1937 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1938 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1939 aStudyBuilder->RemoveObjectWithChildren( SO );
1941 else {// default action: remove SObject from the study
1942 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1943 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1945 aStudyBuilder->RemoveObjectWithChildren( SO );
1949 } /* listSO back loop */
1951 aStudyBuilder->CommitCommand();
1953 /* Clear any previous selection */
1955 aSel->setSelectedObjects( l1 );
1957 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1961 SMESHGUI_EXPORT CAM_Module* createModule()
1963 return new SMESHGUI();
1966 SMESHGUI_EXPORT char* getModuleVersion() {
1967 return (char*)SMESH_VERSION_STR;
1971 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1973 //=============================================================================
1977 //=============================================================================
1978 SMESHGUI::SMESHGUI() :
1979 SalomeApp_Module( "SMESH" )
1981 if ( CORBA::is_nil( myComponentSMESH ) )
1983 CORBA::Boolean anIsEmbeddedMode;
1984 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1985 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1987 // 0019923: EDF 765 SMESH : default values of hypothesis
1988 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1989 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1990 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1991 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1992 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1994 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1995 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1996 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1998 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1999 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2003 myActiveDialogBox = 0;
2004 myFilterLibraryDlg = 0;
2008 myEventCallbackCommand = vtkCallbackCommand::New();
2009 myEventCallbackCommand->Delete();
2010 myEventCallbackCommand->SetClientData( this );
2011 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2014 /* load resources for all available meshers */
2015 SMESH::InitAvailableHypotheses();
2018 //=============================================================================
2022 //=============================================================================
2023 SMESHGUI::~SMESHGUI()
2027 //=============================================================================
2031 //=============================================================================
2032 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2034 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2036 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2041 //=============================================================================
2045 //=============================================================================
2046 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2048 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2052 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2053 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2054 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2055 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2056 return autoUpdate && !exceeded;
2059 //=============================================================================
2063 //=============================================================================
2064 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2065 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2067 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2071 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2072 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2073 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2075 SMESH::long_array_var info = theMesh->GetMeshInfo();
2076 long nbOdElems = info[SMDSEntity_0D];
2077 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2078 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2079 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2080 info[SMDSEntity_Polygon];
2081 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2082 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2083 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2084 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2085 info[SMDSEntity_Polyhedra] +
2086 info[SMDSEntity_Hexagonal_Prism];
2087 long nbBalls = info[SMDSEntity_Ball];
2089 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2090 *nbElements = requestedSize;
2092 *entities = SMESH_Actor::eAllEntity;
2095 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2097 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2099 if ( incrementalLimit ) {
2102 if ( nbOdElems > 0 ) {
2103 if ( total + nbOdElems > updateLimit ) {
2104 *entities = *entities & ~SMESH_Actor::e0DElements;
2105 *hidden = *hidden | SMESH_Actor::e0DElements;
2112 if ( nbEdges > 0 ) {
2113 if ( total + nbEdges > updateLimit ) {
2114 *entities = *entities & ~SMESH_Actor::eEdges;
2115 *hidden = *hidden | SMESH_Actor::eEdges;
2122 if ( nbFaces > 0 ) {
2123 if ( total + nbFaces > updateLimit ) {
2124 *entities = *entities & ~SMESH_Actor::eFaces;
2125 *hidden = *hidden | SMESH_Actor::eFaces;
2132 if ( nbVolumes > 0 ) {
2133 if ( total + nbVolumes > updateLimit ) {
2134 *entities = *entities & ~SMESH_Actor::eVolumes;
2135 *hidden = *hidden | SMESH_Actor::eVolumes;
2142 if ( nbBalls > 0 ) {
2143 if ( total + nbBalls > updateLimit ) {
2144 *entities = *entities & ~SMESH_Actor::eBallElem;
2145 *hidden = *hidden | SMESH_Actor::eBallElem;
2153 return autoUpdate && !exceeded;
2156 //=============================================================================
2160 //=============================================================================
2161 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2163 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2166 //=============================================================================
2170 //=============================================================================
2171 SMESHGUI* SMESHGUI::GetSMESHGUI()
2173 SMESHGUI* smeshMod = 0;
2174 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2177 CAM_Module* module = app->module( "Mesh" );
2178 smeshMod = dynamic_cast<SMESHGUI*>( module );
2181 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2183 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2186 _PTR(Study) aStudy = study->studyDS();
2188 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2197 Standard_EXPORT SMESHGUI* GetComponentGUI()
2199 return SMESHGUI::GetSMESHGUI();
2203 //=============================================================================
2207 //=============================================================================
2208 void SMESHGUI::SetState(int aState)
2213 //=============================================================================
2217 //=============================================================================
2218 void SMESHGUI::ResetState()
2223 //=============================================================================
2227 //=============================================================================
2228 void SMESHGUI::EmitSignalDeactivateDialog()
2230 emit SignalDeactivateActiveDialog();
2233 //=============================================================================
2237 //=============================================================================
2238 void SMESHGUI::EmitSignalStudyFrameChanged()
2240 emit SignalStudyFrameChanged();
2243 //=============================================================================
2247 //=============================================================================
2248 void SMESHGUI::EmitSignalCloseAllDialogs()
2250 emit SignalCloseAllDialogs();
2253 //=============================================================================
2257 //=============================================================================
2258 void SMESHGUI::EmitSignalVisibilityChanged()
2260 emit SignalVisibilityChanged();
2263 //=============================================================================
2267 //=============================================================================
2268 QDialog *SMESHGUI::GetActiveDialogBox()
2270 return myActiveDialogBox;
2273 //=============================================================================
2277 //=============================================================================
2278 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2280 myActiveDialogBox = (QDialog *) aDlg;
2284 //=============================================================================
2288 //=============================================================================
2289 SUIT_Desktop* SMESHGUI::desktop()
2291 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2293 return app->desktop();
2298 //=============================================================================
2302 //=============================================================================
2303 SalomeApp_Study* SMESHGUI::activeStudy()
2305 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2307 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2312 //=============================================================================
2316 //=============================================================================
2317 void SMESHGUI::Modified( bool theIsUpdateActions )
2319 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2320 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2321 appStudy->Modified();
2322 if( theIsUpdateActions )
2323 app->updateActions();
2328 //=============================================================================
2332 //=============================================================================
2333 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2335 /* Here the position is on the bottom right corner - 10 */
2336 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2338 SUIT_Desktop *PP = desktop();
2339 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2340 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2344 //=============================================================================
2348 //=============================================================================
2349 static int isStudyLocked(_PTR(Study) theStudy){
2350 return theStudy->GetProperties()->IsLocked();
2353 static bool checkLock(_PTR(Study) theStudy) {
2354 if (isStudyLocked(theStudy)) {
2355 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2356 QObject::tr("WRN_WARNING"),
2357 QObject::tr("WRN_STUDY_LOCKED") );
2363 //=======================================================================
2364 //function : CheckActiveStudyLocked
2366 //=======================================================================
2368 bool SMESHGUI::isActiveStudyLocked()
2370 _PTR(Study) aStudy = activeStudy()->studyDS();
2371 return checkLock( aStudy );
2374 //=============================================================================
2378 //=============================================================================
2379 bool SMESHGUI::OnGUIEvent( int theCommandID )
2381 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2385 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2386 SUIT_ResourceMgr* mgr = resourceMgr();
2390 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2391 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2394 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2395 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2397 //QAction* act = action( theCommandID );
2399 switch (theCommandID) {
2400 case SMESHOp::OpDelete:
2401 if(checkLock(aStudy)) break;
2404 case SMESHOp::OpImportDAT:
2405 case SMESHOp::OpImportUNV:
2406 case SMESHOp::OpImportMED:
2407 case SMESHOp::OpImportSTL:
2409 case SMESHOp::OpImportCGNS:
2411 case SMESHOp::OpImportSAUV:
2412 case SMESHOp::OpImportGMF:
2414 if(checkLock(aStudy)) break;
2415 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2419 case SMESHOp::OpFileInformation:
2421 SALOME_ListIO selected;
2422 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2424 aSel->selectedObjects( selected );
2425 if( selected.Extent() )
2427 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2428 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2429 if ( !aMesh->_is_nil() )
2431 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2437 case SMESHOp::OpExportDAT:
2438 case SMESHOp::OpExportMED:
2439 case SMESHOp::OpExportUNV:
2440 case SMESHOp::OpExportSTL:
2442 case SMESHOp::OpExportCGNS:
2444 case SMESHOp::OpExportSAUV:
2445 case SMESHOp::OpExportGMF:
2446 case SMESHOp::OpPopupExportDAT:
2447 case SMESHOp::OpPopupExportMED:
2448 case SMESHOp::OpPopupExportUNV:
2449 case SMESHOp::OpPopupExportSTL:
2451 case SMESHOp::OpPopupExportCGNS:
2453 case SMESHOp::OpPopupExportSAUV:
2454 case SMESHOp::OpPopupExportGMF:
2456 ::ExportMeshToFile(theCommandID);
2460 case SMESHOp::OpReset: // SCALAR BAR
2462 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2463 SALOME_ListIO selected;
2465 aSel->selectedObjects( selected );
2467 if( selected.Extent() ) {
2468 Handle(SALOME_InteractiveObject) anIO = selected.First();
2469 if( anIO->hasEntry() ) {
2470 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2471 anActor->SetControlMode( SMESH_Actor::eNone );
2472 #ifndef DISABLE_PLOT2DVIEWER
2473 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2480 case SMESHOp::OpScalarBarProperties:
2482 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2485 case SMESHOp::OpSaveDistribution:
2487 // dump control distribution data to the text file
2488 ::SaveDistribution();
2492 case SMESHOp::OpShowDistribution:
2494 // show/ distribution
2495 ::ShowDistribution();
2499 #ifndef DISABLE_PLOT2DVIEWER
2500 case SMESHOp::OpPlotDistribution:
2502 // plot distribution
2503 ::PlotDistribution();
2509 case SMESHOp::OpAutoColor:
2513 case SMESHOp::OpDisableAutoColor:
2514 ::DisableAutoColor();
2517 case SMESHOp::OpClipping:
2518 case SMESHOp::OpTransparency:
2519 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2522 case SMESHOp::OpDMWireframe:
2523 case SMESHOp::OpDMShading:
2524 case SMESHOp::OpDMNodes:
2525 case SMESHOp::OpDMShrink:
2526 ::SetDisplayMode(theCommandID, myMarkerMap);
2529 //2D quadratic representation
2530 case SMESHOp::OpRepresentationLines:
2531 case SMESHOp::OpRepresentationArcs:
2532 ::SetDisplayMode(theCommandID, myMarkerMap);
2536 case SMESHOp::OpDE0DElements:
2537 case SMESHOp::OpDEEdges:
2538 case SMESHOp::OpDEFaces:
2539 case SMESHOp::OpDEVolumes:
2540 case SMESHOp::OpDEBalls:
2541 case SMESHOp::OpDEAllEntity:
2542 ::SetDisplayEntity(theCommandID);
2545 // Choose entities to be displayed
2546 case SMESHOp::OpDEChoose:
2548 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2552 case SMESHOp::OpOrientationOnFaces:
2554 LightApp_SelectionMgr* mgr = selectionMgr();
2555 SALOME_ListIO selected; mgr->selectedObjects( selected );
2557 SALOME_ListIteratorOfListIO it(selected);
2558 for( ; it.More(); it.Next()) {
2559 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2560 if(anIObject->hasEntry()) {
2561 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2562 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2569 case SMESHOp::OpUpdate:
2571 if(checkLock(aStudy)) break;
2572 SUIT_OverrideCursor wc;
2574 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2577 SMESH::UpdateView();
2579 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2580 SMESH::OnVisuException();
2582 catch (...) { // PAL16774 (Crash after display of many groups)
2583 SMESH::OnVisuException();
2587 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2588 aSel->selectedObjects( l );
2589 aSel->setSelectedObjects( l );
2593 case SMESHOp::OpHide:
2594 case SMESHOp::OpShow:
2595 case SMESHOp::OpShowOnly:
2597 SMESH::EDisplaing anAction;
2598 switch (theCommandID) {
2599 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2600 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2601 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2604 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2605 SALOME_ListIO sel_objects, to_process;
2607 aSel->selectedObjects( sel_objects );
2609 if( theCommandID==SMESHOp::OpShowOnly )
2611 MESSAGE("anAction = SMESH::eDisplayOnly");
2612 startOperation( myEraseAll );
2615 extractContainers( sel_objects, to_process );
2618 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2622 SALOME_ListIteratorOfListIO It( to_process );
2623 for ( ; It.More(); It.Next()) {
2625 Handle(SALOME_InteractiveObject) IOS = It.Value();
2626 if (IOS->hasEntry()) {
2628 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2629 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2630 break; // PAL16774 (Crash after display of many groups)
2632 if (anAction == SMESH::eDisplayOnly)
2634 MESSAGE("anAction = SMESH::eDisplayOnly");
2635 anAction = SMESH::eDisplay;
2641 // PAL13338 + PAL15161 -->
2642 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2643 MESSAGE("anAction = SMESH::eDisplayOnly");
2644 SMESH::UpdateView();
2645 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2647 // PAL13338 + PAL15161 <--
2649 catch (...) { // PAL16774 (Crash after display of many groups)
2650 SMESH::OnVisuException();
2653 if (anAction == SMESH::eErase) {
2654 MESSAGE("anAction == SMESH::eErase");
2656 aSel->setSelectedObjects( l1 );
2659 aSel->setSelectedObjects( to_process );
2664 case SMESHOp::OpNode:
2666 if(checkLock(aStudy)) break;
2669 EmitSignalDeactivateDialog();
2671 ( new SMESHGUI_NodesDlg( this ) )->show();
2674 SUIT_MessageBox::warning(desktop(),
2675 tr("SMESH_WRN_WARNING"),
2676 tr("SMESH_WRN_VIEWER_VTK"));
2681 case SMESHOp::OpCreateMesh:
2682 case SMESHOp::OpCreateSubMesh:
2683 case SMESHOp::OpEditMeshOrSubMesh:
2684 case SMESHOp::OpCompute:
2685 case SMESHOp::OpPreCompute:
2686 case SMESHOp::OpEvaluate:
2687 case SMESHOp::OpMeshOrder:
2688 startOperation( theCommandID );
2690 case SMESHOp::OpCopyMesh:
2692 if (checkLock(aStudy)) break;
2693 EmitSignalDeactivateDialog();
2694 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2697 case SMESHOp::OpBuildCompoundMesh:
2699 if (checkLock(aStudy)) break;
2700 EmitSignalDeactivateDialog();
2701 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2705 case SMESHOp::OpDiagonalInversion:
2706 case SMESHOp::OpUnionOfTwoTriangle:
2710 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2711 tr( "NOT_A_VTK_VIEWER" ) );
2715 if ( checkLock( aStudy ) )
2718 /*Standard_Boolean aRes;
2719 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2720 if ( aMesh->_is_nil() )
2722 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2723 tr( "SMESH_BAD_SELECTION" ) );
2727 EmitSignalDeactivateDialog();
2728 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2729 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2731 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2734 case SMESHOp::OpOrientation:
2735 case SMESHOp::OpUnionOfTriangles:
2736 case SMESHOp::OpCuttingOfQuadrangles:
2737 case SMESHOp::OpSplitVolumes:
2741 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2742 tr( "NOT_A_VTK_VIEWER" ) );
2746 if ( checkLock( aStudy ) )
2749 EmitSignalDeactivateDialog();
2750 SMESHGUI_MultiEditDlg* aDlg = NULL;
2751 if ( theCommandID == SMESHOp::OpOrientation )
2752 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2753 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2754 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2755 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2756 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2758 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2763 case SMESHOp::OpSmoothing:
2765 if(checkLock(aStudy)) break;
2767 EmitSignalDeactivateDialog();
2768 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2771 SUIT_MessageBox::warning(desktop(),
2772 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2776 case SMESHOp::OpExtrusion:
2778 if (checkLock(aStudy)) break;
2780 EmitSignalDeactivateDialog();
2781 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2783 SUIT_MessageBox::warning(desktop(),
2784 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2788 case SMESHOp::OpExtrusionAlongAPath:
2790 if (checkLock(aStudy)) break;
2792 EmitSignalDeactivateDialog();
2793 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2795 SUIT_MessageBox::warning(desktop(),
2796 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2800 case SMESHOp::OpRevolution:
2802 if(checkLock(aStudy)) break;
2804 EmitSignalDeactivateDialog();
2805 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2808 SUIT_MessageBox::warning(desktop(),
2809 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2813 case SMESHOp::OpPatternMapping:
2815 if ( checkLock( aStudy ) )
2819 EmitSignalDeactivateDialog();
2820 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2823 SUIT_MessageBox::warning(desktop(),
2824 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2828 case SMESHOp::OpConvertMeshToQuadratic:
2829 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2830 case SMESHOp::OpReorientFaces:
2831 case SMESHOp::OpCreateGeometryGroup:
2833 startOperation( theCommandID );
2836 case SMESHOp::OpCreateGroup:
2840 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2841 tr( "NOT_A_VTK_VIEWER" ) );
2845 if(checkLock(aStudy)) break;
2846 EmitSignalDeactivateDialog();
2847 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2849 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2850 SALOME_ListIO selected;
2852 aSel->selectedObjects( selected );
2854 int nbSel = selected.Extent();
2856 // check if mesh is selected
2857 aMesh = SMESH::GetMeshByIO( selected.First() );
2859 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2864 case SMESHOp::OpConstructGroup:
2868 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2869 tr( "NOT_A_VTK_VIEWER" ) );
2873 if(checkLock(aStudy)) break;
2874 EmitSignalDeactivateDialog();
2876 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2877 SALOME_ListIO selected;
2879 aSel->selectedObjects( selected );
2881 int nbSel = selected.Extent();
2883 // check if submesh is selected
2884 Handle(SALOME_InteractiveObject) IObject = selected.First();
2885 if (IObject->hasEntry()) {
2886 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2888 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2889 if (!aSubMesh->_is_nil()) {
2891 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2892 // get submesh elements list by types
2893 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2894 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2895 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2896 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2897 // create group for each type o elements
2898 QString aName = IObject->getName();
2899 QStringList anEntryList;
2900 if (aNodes->length() > 0) {
2901 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2902 aGroup->Add(aNodes.inout());
2903 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2904 anEntryList.append( aSObject->GetID().c_str() );
2906 if (aEdges->length() > 0) {
2907 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2908 aGroup->Add(aEdges.inout());
2909 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2910 anEntryList.append( aSObject->GetID().c_str() );
2912 if (aFaces->length() > 0) {
2913 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2914 aGroup->Add(aFaces.inout());
2915 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2916 anEntryList.append( aSObject->GetID().c_str() );
2918 if (aVolumes->length() > 0) {
2919 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2920 aGroup->Add(aVolumes.inout());
2921 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2922 anEntryList.append( aSObject->GetID().c_str() );
2925 anApp->browseObjects( anEntryList );
2927 catch(const SALOME::SALOME_Exception & S_ex){
2928 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2935 SUIT_MessageBox::warning(desktop(),
2936 tr("SMESH_WRN_WARNING"),
2937 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2942 case SMESHOp::OpEditGroup:
2946 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2947 tr( "NOT_A_VTK_VIEWER" ) );
2951 if(checkLock(aStudy)) break;
2952 EmitSignalDeactivateDialog();
2954 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2955 SALOME_ListIO selected;
2957 aSel->selectedObjects( selected );
2959 SALOME_ListIteratorOfListIO It (selected);
2960 int nbSelectedGroups = 0;
2961 for ( ; It.More(); It.Next() )
2963 SMESH::SMESH_GroupBase_var aGroup =
2964 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2965 if (!aGroup->_is_nil()) {
2967 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2971 if (nbSelectedGroups == 0)
2973 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2979 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2981 if(checkLock(aStudy)) break;
2982 if (myState == 800) {
2983 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2984 if (aDlg) aDlg->onAdd();
2989 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2991 if(checkLock(aStudy)) break;
2992 if (myState == 800) {
2993 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2994 if (aDlg) aDlg->onRemove();
2999 case SMESHOp::OpEditGeomGroupAsGroup:
3003 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3004 tr( "NOT_A_VTK_VIEWER" ) );
3008 if(checkLock(aStudy)) break;
3009 EmitSignalDeactivateDialog();
3011 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3012 SALOME_ListIO selected;
3014 aSel->selectedObjects( selected );
3016 SALOME_ListIteratorOfListIO It (selected);
3017 for ( ; It.More(); It.Next() )
3019 SMESH::SMESH_GroupOnGeom_var aGroup =
3020 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3021 if (!aGroup->_is_nil()) {
3022 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3027 SMESH::SMESH_GroupOnFilter_var aGroup =
3028 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3029 if (!aGroup->_is_nil()) {
3030 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3038 case SMESHOp::OpUnionGroups:
3039 case SMESHOp::OpIntersectGroups:
3040 case SMESHOp::OpCutGroups:
3044 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3045 tr( "NOT_A_VTK_VIEWER" ) );
3049 if ( checkLock( aStudy ) )
3052 EmitSignalDeactivateDialog();
3054 SMESHGUI_GroupOpDlg* aDlg = 0;
3055 if ( theCommandID == SMESHOp::OpUnionGroups )
3056 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3057 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3058 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3060 aDlg = new SMESHGUI_CutGroupsDlg( this );
3067 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3069 if ( checkLock( aStudy ) )
3072 EmitSignalDeactivateDialog();
3073 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3079 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3083 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3084 tr( "NOT_A_VTK_VIEWER" ) );
3088 if ( checkLock( aStudy ) )
3091 EmitSignalDeactivateDialog();
3093 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3097 case SMESHOp::OpMeshInformation:
3098 case SMESHOp::OpWhatIs:
3100 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3101 EmitSignalDeactivateDialog();
3102 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3103 SALOME_ListIO selected;
3105 aSel->selectedObjects( selected );
3107 if ( selected.Extent() > 1 ) { // a dlg for each IO
3108 SALOME_ListIteratorOfListIO It( selected );
3109 for ( ; It.More(); It.Next() ) {
3110 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3111 dlg->showInfo( It.Value() );
3116 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3122 case SMESHOp::OpFindElementByPoint:
3124 startOperation( theCommandID );
3128 case SMESHOp::OpEditHypothesis:
3130 if(checkLock(aStudy)) break;
3132 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3133 SALOME_ListIO selected;
3135 aSel->selectedObjects( selected );
3137 int nbSel = selected.Extent();
3140 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3141 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3143 if ( !aHypothesis->_is_nil() )
3145 SMESHGUI_GenericHypothesisCreator* aCreator =
3146 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3149 // set geometry of mesh and sub-mesh to aCreator
3150 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3151 if ( selected.Extent() == 1 )
3153 QString subGeomID, meshGeomID;
3154 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3155 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3157 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3158 aCreator->setShapeEntry( subGeomID );
3159 aCreator->setMainShapeEntry( meshGeomID );
3163 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3173 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3175 if(checkLock(aStudy)) break;
3176 SUIT_OverrideCursor wc;
3178 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3179 SALOME_ListIO selected;
3181 aSel->selectedObjects( selected, QString::null, false );
3183 SALOME_ListIteratorOfListIO It(selected);
3184 for (int i = 0; It.More(); It.Next(), i++) {
3185 Handle(SALOME_InteractiveObject) IObject = It.Value();
3186 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3189 aSel->setSelectedObjects( l1 );
3194 case SMESHOp::OpElem0D:
3195 case SMESHOp::OpBall:
3196 case SMESHOp::OpEdge:
3197 case SMESHOp::OpTriangle:
3198 case SMESHOp::OpQuadrangle:
3199 case SMESHOp::OpPolygon:
3200 case SMESHOp::OpTetrahedron:
3201 case SMESHOp::OpHexahedron:
3202 case SMESHOp::OpPentahedron:
3203 case SMESHOp::OpPyramid:
3204 case SMESHOp::OpHexagonalPrism:
3206 if(checkLock(aStudy)) break;
3208 EmitSignalDeactivateDialog();
3209 SMDSAbs_EntityType type = SMDSEntity_Edge;
3210 switch (theCommandID) {
3211 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3212 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3213 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3214 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3215 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3216 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3217 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3218 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3219 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3220 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3223 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3226 SUIT_MessageBox::warning(desktop(),
3227 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3231 case SMESHOp::OpPolyhedron:
3233 if(checkLock(aStudy)) break;
3235 EmitSignalDeactivateDialog();
3236 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3239 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3240 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3244 case SMESHOp::OpQuadraticEdge:
3245 case SMESHOp::OpQuadraticTriangle:
3246 case SMESHOp::OpBiQuadraticTriangle:
3247 case SMESHOp::OpQuadraticQuadrangle:
3248 case SMESHOp::OpBiQuadraticQuadrangle:
3249 case SMESHOp::OpQuadraticTetrahedron:
3250 case SMESHOp::OpQuadraticPyramid:
3251 case SMESHOp::OpQuadraticPentahedron:
3252 case SMESHOp::OpQuadraticHexahedron:
3253 case SMESHOp::OpTriQuadraticHexahedron:
3255 if(checkLock(aStudy)) break;
3257 EmitSignalDeactivateDialog();
3258 SMDSAbs_EntityType type = SMDSEntity_Last;
3260 switch (theCommandID) {
3261 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3262 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3263 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3264 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3265 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3266 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3267 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3268 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3269 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3270 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3273 if ( type != SMDSEntity_Last )
3274 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3277 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3278 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3282 case SMESHOp::OpRemoveNodes:
3284 if(checkLock(aStudy)) break;
3286 EmitSignalDeactivateDialog();
3287 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3290 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3291 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3295 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3297 if(checkLock(aStudy)) break;
3299 EmitSignalDeactivateDialog();
3300 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3304 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3305 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3309 case SMESHOp::OpClearMesh: {
3311 if(checkLock(aStudy)) break;
3313 SALOME_ListIO selected;
3314 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3315 aSel->selectedObjects( selected );
3317 SUIT_OverrideCursor wc;
3318 SALOME_ListIteratorOfListIO It (selected);
3319 for ( ; It.More(); It.Next() )
3321 Handle(SALOME_InteractiveObject) IOS = It.Value();
3322 SMESH::SMESH_Mesh_var aMesh =
3323 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3324 if ( aMesh->_is_nil()) continue;
3326 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3328 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3329 SMESH::ModifiedMesh( aMeshSObj, false, true);
3330 // hide groups and submeshes
3331 _PTR(ChildIterator) anIter =
3332 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3333 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3335 _PTR(SObject) so = anIter->Value();
3336 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3339 catch (const SALOME::SALOME_Exception& S_ex){
3341 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3345 SMESH::UpdateView();
3349 case SMESHOp::OpRemoveOrphanNodes:
3351 if(checkLock(aStudy)) break;
3352 SALOME_ListIO selected;
3353 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3354 aSel->selectedObjects( selected );
3355 if ( selected.Extent() == 1 ) {
3356 Handle(SALOME_InteractiveObject) anIO = selected.First();
3357 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3358 if ( !aMesh->_is_nil() ) {
3359 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3360 tr( "SMESH_WARNING" ),
3361 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3362 SUIT_MessageBox::Yes |
3363 SUIT_MessageBox::No,
3364 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3367 SUIT_OverrideCursor wc;
3368 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3369 int removed = aMeshEditor->RemoveOrphanNodes();
3370 SUIT_MessageBox::information(SMESHGUI::desktop(),
3371 tr("SMESH_INFORMATION"),
3372 tr("NB_NODES_REMOVED").arg(removed));
3373 if ( removed > 0 ) {
3374 SMESH::UpdateView();
3375 SMESHGUI::Modified();
3378 catch (const SALOME::SALOME_Exception& S_ex) {
3379 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3388 case SMESHOp::OpRenumberingNodes:
3390 if(checkLock(aStudy)) break;
3392 EmitSignalDeactivateDialog();
3393 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3397 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3398 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3402 case SMESHOp::OpRenumberingElements:
3404 if(checkLock(aStudy)) break;
3406 EmitSignalDeactivateDialog();
3407 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3411 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3412 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3416 case SMESHOp::OpTranslation:
3418 if(checkLock(aStudy)) break;
3420 EmitSignalDeactivateDialog();
3421 ( new SMESHGUI_TranslationDlg( this ) )->show();
3424 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3425 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3429 case SMESHOp::OpRotation:
3431 if(checkLock(aStudy)) break;
3433 EmitSignalDeactivateDialog();
3434 ( new SMESHGUI_RotationDlg( this ) )->show();
3437 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3438 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3442 case SMESHOp::OpSymmetry:
3444 if(checkLock(aStudy)) break;
3446 EmitSignalDeactivateDialog();
3447 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3450 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3451 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3455 case SMESHOp::OpScale:
3457 if(checkLock(aStudy)) break;
3459 EmitSignalDeactivateDialog();
3460 ( new SMESHGUI_ScaleDlg( this ) )->show();
3463 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3464 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3469 case SMESHOp::OpSewing:
3471 if(checkLock(aStudy)) break;
3473 EmitSignalDeactivateDialog();
3474 ( new SMESHGUI_SewingDlg( this ) )->show();
3477 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3478 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3482 case SMESHOp::OpMergeNodes:
3484 if(checkLock(aStudy)) break;
3486 EmitSignalDeactivateDialog();
3487 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3490 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3491 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3495 case SMESHOp::OpMergeElements:
3497 if (checkLock(aStudy)) break;
3499 EmitSignalDeactivateDialog();
3500 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3502 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3503 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3508 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3509 startOperation( SMESHOp::OpMoveNode );
3512 case SMESHOp::OpDuplicateNodes:
3514 if(checkLock(aStudy)) break;
3516 EmitSignalDeactivateDialog();
3517 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3520 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3521 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3526 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3527 startOperation( SMESHOp::OpElem0DOnElemNodes );
3530 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3532 static QList<int> aTypes;
3533 if ( aTypes.isEmpty() )
3535 aTypes.append( SMESH::NODE );
3536 aTypes.append( SMESH::EDGE );
3537 aTypes.append( SMESH::FACE );
3538 aTypes.append( SMESH::VOLUME );
3540 if (!myFilterLibraryDlg)
3541 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3542 else if (myFilterLibraryDlg->isHidden())
3543 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3544 myFilterLibraryDlg->raise();
3548 case SMESHOp::OpFreeNode:
3549 case SMESHOp::OpEqualNode:
3550 case SMESHOp::OpFreeEdge:
3551 case SMESHOp::OpFreeBorder:
3552 case SMESHOp::OpLength:
3553 case SMESHOp::OpConnection:
3554 case SMESHOp::OpEqualEdge:
3555 case SMESHOp::OpFreeFace:
3556 case SMESHOp::OpBareBorderFace:
3557 case SMESHOp::OpOverConstrainedFace:
3558 case SMESHOp::OpLength2D:
3559 case SMESHOp::OpConnection2D:
3560 case SMESHOp::OpArea:
3561 case SMESHOp::OpTaper:
3562 case SMESHOp::OpAspectRatio:
3563 case SMESHOp::OpMinimumAngle:
3564 case SMESHOp::OpWarpingAngle:
3565 case SMESHOp::OpSkew:
3566 case SMESHOp::OpMaxElementLength2D:
3567 case SMESHOp::OpEqualFace:
3568 case SMESHOp::OpAspectRatio3D:
3569 case SMESHOp::OpVolume:
3570 case SMESHOp::OpMaxElementLength3D:
3571 case SMESHOp::OpBareBorderVolume:
3572 case SMESHOp::OpOverConstrainedVolume:
3573 case SMESHOp::OpEqualVolume:
3576 LightApp_SelectionMgr* mgr = selectionMgr();
3577 SALOME_ListIO selected; mgr->selectedObjects( selected );
3579 if( !selected.IsEmpty() ) {
3580 SUIT_OverrideCursor wc;
3581 ::Control( theCommandID );
3584 SUIT_MessageBox::warning(desktop(),
3585 tr( "SMESH_WRN_WARNING" ),
3586 tr( "SMESH_BAD_SELECTION" ) );
3590 SUIT_MessageBox::warning(desktop(),
3591 tr( "SMESH_WRN_WARNING" ),
3592 tr( "NOT_A_VTK_VIEWER" ) );
3595 case SMESHOp::OpOverallMeshQuality:
3596 OverallMeshQuality();
3598 case SMESHOp::OpNumberingNodes:
3600 SUIT_OverrideCursor wc;
3601 LightApp_SelectionMgr* mgr = selectionMgr();
3602 SALOME_ListIO selected; mgr->selectedObjects( selected );
3604 SALOME_ListIteratorOfListIO it(selected);
3605 for( ; it.More(); it.Next()) {
3606 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3607 if(anIObject->hasEntry()) {
3608 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3609 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3615 case SMESHOp::OpNumberingElements:
3617 SUIT_OverrideCursor wc;
3618 LightApp_SelectionMgr* mgr = selectionMgr();
3619 SALOME_ListIO selected; mgr->selectedObjects( selected );
3621 SALOME_ListIteratorOfListIO it(selected);
3622 for( ; it.More(); it.Next()) {
3623 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3624 if(anIObject->hasEntry())
3625 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3626 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3631 case SMESHOp::OpPropertiesLength:
3632 case SMESHOp::OpPropertiesArea:
3633 case SMESHOp::OpPropertiesVolume:
3634 case SMESHOp::OpMinimumDistance:
3635 case SMESHOp::OpBoundingBox:
3637 int page = SMESHGUI_MeasureDlg::MinDistance;
3638 if ( theCommandID == SMESHOp::OpBoundingBox )
3639 page = SMESHGUI_MeasureDlg::BoundingBox;
3640 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3641 page = SMESHGUI_MeasureDlg::Length;
3642 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3643 page = SMESHGUI_MeasureDlg::Area;
3644 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3645 page = SMESHGUI_MeasureDlg::Volume;
3647 EmitSignalDeactivateDialog();
3648 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3652 case SMESHOp::OpSortChild:
3658 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3659 //updateObjBrowser();
3663 //=============================================================================
3667 //=============================================================================
3668 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3673 //=============================================================================
3677 //=============================================================================
3678 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3683 //=============================================================================
3687 //=============================================================================
3688 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3693 //=============================================================================
3694 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3695 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3697 //=============================================================================
3698 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3699 SUIT_ViewWindow* wnd )
3701 if(theIO->hasEntry()){
3702 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3703 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3707 //=======================================================================
3708 // function : createSMESHAction
3710 //=======================================================================
3711 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3712 const int key, const bool toggle, const QString& shortcutAction )
3715 QWidget* parent = application()->desktop();
3716 SUIT_ResourceMgr* resMgr = resourceMgr();
3718 if ( !icon_id.isEmpty() )
3719 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3721 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3722 if ( !pix.isNull() )
3723 icon = QIcon( pix );
3725 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3726 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3727 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3729 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3730 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3733 //=======================================================================
3734 // function : createPopupItem
3736 //=======================================================================
3737 void SMESHGUI::createPopupItem( const int id,
3738 const QString& clients,
3739 const QString& types,
3740 const QString& theRule,
3743 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3744 popupMgr()->insert( action( id ), pId, 0 );
3746 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3747 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3748 QString rule = "(%1) and (%2) and (%3)";
3749 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3750 if( clients.isEmpty() )
3751 rule = rule.arg( QString( "true" ) );
3753 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3754 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3757 bool cont = myRules.contains( id );
3759 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3761 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3762 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3765 //=======================================================================
3766 // function : initialize
3768 //=======================================================================
3769 void SMESHGUI::initialize( CAM_Application* app )
3771 SalomeApp_Module::initialize( app );
3773 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3775 /* Automatic Update flag */
3776 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3778 // ----- create actions --------------
3780 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3781 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3782 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3783 //createSMESHAction( 114, "NUM" );
3784 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3786 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3788 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3789 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3790 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3791 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3792 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3793 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3795 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3797 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3798 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3799 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3800 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3801 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3802 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3804 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3806 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3807 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3808 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3809 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3810 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3811 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3812 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3813 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3814 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3815 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3816 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3817 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3818 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3819 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3820 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3821 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3822 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3823 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3824 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3825 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3826 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3827 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3828 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3829 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3830 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3831 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3832 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3833 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3834 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3835 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3837 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3838 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3839 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3840 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3841 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3842 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3843 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3844 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3845 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3846 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3847 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3848 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3849 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3850 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3851 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3852 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3853 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3854 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3855 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3856 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3857 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3858 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3859 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3860 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3861 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3862 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3863 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3865 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3866 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3867 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3868 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3869 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3870 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3871 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3872 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3873 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3874 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3875 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3876 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3877 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3878 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3879 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3880 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3881 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3882 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3883 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3884 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3885 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3886 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3887 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3888 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3890 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3891 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3892 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3893 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3895 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3896 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3898 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3899 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3900 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3901 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3902 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3903 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3904 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3905 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3906 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3907 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3908 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3909 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3910 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3911 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3912 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3913 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3914 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3915 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3916 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3917 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3918 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3919 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3920 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3922 createSMESHAction( SMESHOp::OpReset, "RESET" );
3923 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3924 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3925 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3926 #ifndef DISABLE_PLOT2DVIEWER
3927 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3929 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3930 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3931 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3932 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3933 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3934 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3935 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3936 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3937 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3938 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3939 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3940 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3941 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3943 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3944 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3946 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3947 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3948 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3949 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3950 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3951 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3952 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3953 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3954 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3956 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3957 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3958 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3959 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3960 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3962 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3963 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3964 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3966 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3968 QList<int> aCtrlActions;
3969 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3970 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3971 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3972 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3973 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3974 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3975 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3976 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3977 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3978 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3979 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3980 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3981 aCtrlGroup->setExclusive( true );
3982 for( int i = 0; i < aCtrlActions.size(); i++ )
3983 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3985 // ----- create menu --------------
3986 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3987 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3988 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3989 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3990 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3991 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3992 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3993 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3995 createMenu( separator(), fileId );
3997 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3998 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3999 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
4000 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
4001 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
4002 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
4003 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4004 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4005 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4006 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4007 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4009 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4010 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4011 createMenu( SMESHOp::OpImportMED, importId, -1 );
4012 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4014 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4016 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4017 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4018 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4019 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4020 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4021 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4023 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4025 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4026 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4027 createMenu( separator(), fileId, 10 );
4029 createMenu( SMESHOp::OpDelete, editId, -1 );
4031 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4033 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4034 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4035 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4036 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4037 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4038 createMenu( separator(), meshId, -1 );
4039 createMenu( SMESHOp::OpCompute, meshId, -1 );
4040 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4041 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4042 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4043 createMenu( separator(), meshId, -1 );
4044 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4045 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4046 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4047 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4048 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4049 createMenu( separator(), meshId, -1 );
4050 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4051 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4052 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4053 createMenu( separator(), meshId, -1 );
4054 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4055 createMenu( separator(), meshId, -1 );
4056 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4057 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4058 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4059 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4060 createMenu( separator(), meshId, -1 );
4062 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4063 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4064 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4065 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4066 createMenu( SMESHOp::OpLength, edgeId, -1 );
4067 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4068 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4069 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4070 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4071 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4072 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4073 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4074 createMenu( SMESHOp::OpArea, faceId, -1 );
4075 createMenu( SMESHOp::OpTaper, faceId, -1 );
4076 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4077 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4078 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4079 createMenu( SMESHOp::OpSkew, faceId, -1 );
4080 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4081 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4082 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4083 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4084 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4085 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4086 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4087 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4088 createMenu( separator(), ctrlId, -1 );
4089 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4090 createMenu( separator(), ctrlId, -1 );
4091 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4093 createMenu( SMESHOp::OpNode, addId, -1 );
4094 createMenu( SMESHOp::OpElem0D, addId, -1 );
4095 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4096 createMenu( SMESHOp::OpBall, addId, -1 );
4097 createMenu( SMESHOp::OpEdge, addId, -1 );
4098 createMenu( SMESHOp::OpTriangle, addId, -1 );
4099 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4100 createMenu( SMESHOp::OpPolygon, addId, -1 );
4101 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4102 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4103 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4104 createMenu( SMESHOp::OpPyramid, addId, -1 );
4105 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4106 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4107 createMenu( separator(), addId, -1 );
4108 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4109 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4110 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4111 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4112 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4113 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4114 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4115 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4116 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4117 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4119 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4120 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4121 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4122 createMenu( separator(), removeId, -1 );
4123 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4124 createMenu( separator(), removeId, -1 );
4125 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4127 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4128 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4130 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4131 createMenu( SMESHOp::OpRotation, transfId, -1 );
4132 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4133 createMenu( SMESHOp::OpScale, transfId, -1 );
4134 createMenu( SMESHOp::OpSewing, transfId, -1 );
4135 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4136 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4137 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4139 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4140 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4141 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4142 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4143 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4144 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4145 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4146 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4147 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4148 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4149 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4150 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4151 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4152 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4153 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4155 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4156 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4157 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4158 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4159 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4160 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4162 // ----- create toolbars --------------
4163 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4164 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4165 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4166 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4167 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4168 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4169 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4170 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4171 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4172 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4173 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4174 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4175 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4176 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4177 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4179 createTool( SMESHOp::OpCreateMesh, meshTb );
4180 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4181 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4182 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4183 createTool( SMESHOp::OpCopyMesh, meshTb );
4184 createTool( separator(), meshTb );
4185 createTool( SMESHOp::OpCompute, meshTb );
4186 createTool( SMESHOp::OpPreCompute, meshTb );
4187 createTool( SMESHOp::OpEvaluate, meshTb );
4188 createTool( SMESHOp::OpMeshOrder, meshTb );
4190 createTool( SMESHOp::OpCreateGroup, groupTb );
4191 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4192 createTool( SMESHOp::OpConstructGroup, groupTb );
4193 createTool( SMESHOp::OpEditGroup, groupTb );
4195 createTool( SMESHOp::OpMeshInformation, info );
4196 //createTool( SMESHOp::OpStdInfo, meshTb );
4197 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4198 createTool( SMESHOp::OpFindElementByPoint, info );
4200 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4201 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4203 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4204 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4205 createTool( SMESHOp::OpLength, ctrl1dTb );
4206 createTool( SMESHOp::OpConnection, ctrl1dTb );
4207 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4209 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4210 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4211 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4212 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4213 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4214 createTool( SMESHOp::OpArea, ctrl2dTb );
4215 createTool( SMESHOp::OpTaper, ctrl2dTb );
4216 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4217 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4218 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4219 createTool( SMESHOp::OpSkew, ctrl2dTb );
4220 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4221 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4223 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4224 createTool( SMESHOp::OpVolume, ctrl3dTb );
4225 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4226 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4227 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4228 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4230 createTool( SMESHOp::OpNode, addElemTb );
4231 createTool( SMESHOp::OpElem0D, addElemTb );
4232 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4233 createTool( SMESHOp::OpBall, addElemTb );
4234 createTool( SMESHOp::OpEdge, addElemTb );
4235 createTool( SMESHOp::OpTriangle, addElemTb );
4236 createTool( SMESHOp::OpQuadrangle, addElemTb );
4237 createTool( SMESHOp::OpPolygon, addElemTb );
4238 createTool( SMESHOp::OpTetrahedron, addElemTb );
4239 createTool( SMESHOp::OpHexahedron, addElemTb );
4240 createTool( SMESHOp::OpPentahedron, addElemTb );
4241 createTool( SMESHOp::OpPyramid, addElemTb );
4242 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4243 createTool( SMESHOp::OpPolyhedron, addElemTb );
4245 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4246 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4247 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4248 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4249 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4250 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4251 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4252 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4253 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4254 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4256 createTool( SMESHOp::OpRemoveNodes, remTb );
4257 createTool( SMESHOp::OpRemoveElements, remTb );
4258 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4259 createTool( SMESHOp::OpClearMesh, remTb );
4261 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4262 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4264 createTool( SMESHOp::OpTranslation, transformTb );
4265 createTool( SMESHOp::OpRotation, transformTb );
4266 createTool( SMESHOp::OpSymmetry, transformTb );
4267 createTool( SMESHOp::OpScale, transformTb );
4268 createTool( SMESHOp::OpSewing, transformTb );
4269 createTool( SMESHOp::OpMergeNodes, transformTb );
4270 createTool( SMESHOp::OpMergeElements, transformTb );
4271 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4273 createTool( SMESHOp::OpMoveNode, modifyTb );
4274 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4275 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4276 createTool( SMESHOp::OpOrientation, modifyTb );
4277 createTool( SMESHOp::OpReorientFaces, modifyTb );
4278 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4279 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4280 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4281 createTool( SMESHOp::OpSmoothing, modifyTb );
4282 createTool( SMESHOp::OpExtrusion, modifyTb );
4283 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4284 createTool( SMESHOp::OpRevolution, modifyTb );
4285 createTool( SMESHOp::OpPatternMapping, modifyTb );
4286 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4287 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4289 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4291 createTool( SMESHOp::OpUpdate, dispModeTb );
4293 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4294 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4297 QString OB = "'ObjectBrowser'",
4298 View = "'" + SVTK_Viewer::Type() + "'",
4300 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4301 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4302 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4303 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4304 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4305 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4306 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4307 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4308 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4309 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4310 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4312 mesh_part = mesh + " " + subMesh + " " + group,
4313 mesh_group = mesh + " " + group,
4314 hyp_alg = hypo + " " + algo;
4316 // popup for object browser
4318 isInvisible("not( isVisible )"),
4319 isEmpty("numberOfNodes = 0"),
4320 isNotEmpty("numberOfNodes <> 0"),
4322 // has nodes, edges, etc in VISIBLE! actor
4323 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4324 hasElems("(count( elemTypes ) > 0)"),
4325 hasDifferentElems("(count( elemTypes ) > 1)"),
4326 hasBalls("({'BallElem'} in elemTypes)"),
4327 hasElems0d("({'Elem0d'} in elemTypes)"),
4328 hasEdges("({'Edge'} in elemTypes)"),
4329 hasFaces("({'Face'} in elemTypes)"),
4330 hasVolumes("({'Volume'} in elemTypes)");
4332 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4333 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4334 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4335 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4336 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4337 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4339 popupMgr()->insert( separator(), -1, 0 );
4340 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4341 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4342 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4343 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4344 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4345 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4346 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4347 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4348 popupMgr()->insert( separator(), -1, 0 );
4349 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4350 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4351 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4352 popupMgr()->insert( separator(), -1, 0 );
4353 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4354 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4355 popupMgr()->insert( separator(), -1, 0 );
4356 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4357 popupMgr()->insert( separator(), -1, 0 );
4358 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4359 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4361 popupMgr()->insert( separator(), -1, 0 );
4363 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4364 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4365 QString only_one_2D = only_one_non_empty + " && dim>1";
4367 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4368 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4369 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4370 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4372 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4374 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, multiple_non_empty, anId );
4375 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, multiple_non_empty, anId );
4376 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, multiple_non_empty, anId );
4377 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4378 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4379 popupMgr()->insert( separator(), -1, 0 );
4382 createPopupItem( SMESHOp::OpEditGroup, View, group );
4383 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4384 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4386 popupMgr()->insert( separator(), -1, 0 );
4387 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4388 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4389 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4390 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4391 popupMgr()->insert( separator(), -1, 0 );
4393 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4394 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4395 popupMgr()->insert( separator(), -1, 0 );
4397 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4398 QString aType = QString( "%1type in {%2}" ).arg( lc );
4399 aType = aType.arg( mesh_part );
4400 QString aMeshInVTK = aClient + "&&" + aType;
4402 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4403 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4404 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4406 //-------------------------------------------------
4408 //-------------------------------------------------
4409 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4411 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4412 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4413 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4415 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4416 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4417 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4419 popupMgr()->insert( separator(), -1, -1 );
4421 //-------------------------------------------------
4423 //-------------------------------------------------
4424 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4426 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4427 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4428 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4430 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4431 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4432 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4434 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4435 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4436 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4438 popupMgr()->insert( separator(), anId, -1 );
4440 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4441 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4442 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4444 //-------------------------------------------------
4446 //-------------------------------------------------
4447 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4449 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4451 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4452 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4453 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4455 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4456 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4457 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4459 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4460 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4461 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4463 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4464 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4465 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4467 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4468 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4469 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4471 popupMgr()->insert( separator(), anId, -1 );
4473 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4474 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4476 popupMgr()->insert( separator(), anId, -1 );
4478 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4479 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4482 //-------------------------------------------------
4483 // Representation of the 2D Quadratic elements
4484 //-------------------------------------------------
4485 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4486 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4487 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4488 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4490 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4491 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4492 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4494 //-------------------------------------------------
4495 // Orientation of faces
4496 //-------------------------------------------------
4497 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4498 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4499 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4501 //-------------------------------------------------
4503 //-------------------------------------------------
4504 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4505 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4507 //-------------------------------------------------
4509 //-------------------------------------------------
4510 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4511 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4513 //-------------------------------------------------
4515 //-------------------------------------------------
4517 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4518 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4519 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4520 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4522 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4524 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4525 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4527 popupMgr()->insert( separator(), anId, -1 );
4529 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4531 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4532 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4533 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4535 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4536 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4537 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4539 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4541 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4543 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4545 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4546 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4547 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4549 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4550 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4551 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4553 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4554 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4555 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4557 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4558 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4560 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4562 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4564 QtxPopupMgr::VisibleRule );
4565 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4567 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4568 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4569 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4571 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4572 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4573 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4575 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4576 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4579 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4581 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4583 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4584 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4585 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4587 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4588 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4589 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4591 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4592 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4593 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4595 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4597 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4599 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4600 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4601 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4603 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4614 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4616 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4617 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4618 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4620 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4621 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4622 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4624 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4626 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4628 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4630 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4632 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4633 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4634 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4636 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4637 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4638 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4640 popupMgr()->insert( separator(), anId, -1 );
4642 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4645 popupMgr()->insert( separator(), anId, -1 );
4647 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4649 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4652 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4654 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4656 #ifndef DISABLE_PLOT2DVIEWER
4657 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4661 //-------------------------------------------------
4663 //-------------------------------------------------
4664 popupMgr()->insert( separator(), -1, -1 );
4665 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4666 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4667 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4670 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4673 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4676 popupMgr()->insert( separator(), -1, -1 );
4678 //-------------------------------------------------
4680 //-------------------------------------------------
4681 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4682 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4684 popupMgr()->insert( separator(), -1, -1 );
4686 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4688 popupMgr()->insert( separator(), -1, -1 );
4690 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4691 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4693 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4694 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4697 //================================================================================
4699 * \brief Return true if SMESH or GEOM objects are selected.
4700 * Is called form LightApp_Module::activateModule() which clear selection if
4701 * not isSelectionCompatible()
4703 //================================================================================
4705 bool SMESHGUI::isSelectionCompatible()
4707 bool isCompatible = true;
4708 SALOME_ListIO selected;
4709 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4710 Sel->selectedObjects( selected );
4712 SALOME_ListIteratorOfListIO It( selected );
4713 for ( ; isCompatible && It.More(); It.Next())
4715 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4716 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4718 return isCompatible;
4722 bool SMESHGUI::reusableOperation( const int id )
4724 // compute, evaluate and precompute are not reusable operations
4725 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4728 bool SMESHGUI::activateModule( SUIT_Study* study )
4730 bool res = SalomeApp_Module::activateModule( study );
4732 setMenuShown( true );
4733 setToolShown( true );
4735 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4736 PyGILState_STATE gstate = PyGILState_Ensure();
4737 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4738 if ( !pluginsmanager ) {
4742 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4746 PyGILState_Release(gstate);
4747 // end of SMESH plugins loading
4749 // Reset actions accelerator keys
4750 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4752 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4753 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4754 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4755 if ( _PTR(Study) aStudy = s->studyDS()) {
4756 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4757 updateObjBrowser(); // objects can be removed
4760 // get all view currently opened in the study and connect their signals to
4761 // the corresponding slots of the class.
4762 SUIT_Desktop* aDesk = study->application()->desktop();
4764 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4765 SUIT_ViewWindow* wnd;
4766 foreach ( wnd, wndList )
4773 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4775 setMenuShown( false );
4776 setToolShown( false );
4778 EmitSignalCloseAllDialogs();
4780 // Unset actions accelerator keys
4781 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4783 return SalomeApp_Module::deactivateModule( study );
4786 void SMESHGUI::studyClosed( SUIT_Study* s )
4790 SMESH::RemoveVisuData( s->id() );
4791 SalomeApp_Module::studyClosed( s );
4794 void SMESHGUI::OnGUIEvent()
4796 const QObject* obj = sender();
4797 if ( !obj || !obj->inherits( "QAction" ) )
4799 int id = actionId((QAction*)obj);
4804 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4806 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4807 if ( CORBA::is_nil( myComponentSMESH ) )
4809 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4811 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4812 return aGUI.myComponentSMESH;
4815 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4816 return myComponentSMESH;
4819 QString SMESHGUI::engineIOR() const
4821 CORBA::ORB_var anORB = getApp()->orb();
4822 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4823 return QString( anIOR.in() );
4826 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4828 SalomeApp_Module::contextMenuPopup( client, menu, title );
4830 selectionMgr()->selectedObjects( lst );
4831 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4832 Handle(SALOME_InteractiveObject) io = lst.First();
4833 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4834 _PTR(Study) study = appStudy->studyDS();
4835 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4837 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4838 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4839 aName.remove( (aName.length() - 1), 1 );
4845 LightApp_Selection* SMESHGUI::createSelection() const
4847 return new SMESHGUI_Selection();
4850 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4852 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4853 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4854 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4857 void SMESHGUI::viewManagers( QStringList& list ) const
4859 list.append( SVTK_Viewer::Type() );
4862 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4864 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4865 SMESH::UpdateSelectionProp( this );
4867 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4868 for(int i = 0; i < aViews.count() ; i++){
4869 SUIT_ViewWindow *sf = aViews[i];
4875 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4877 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4878 myClippingPlaneInfoMap.erase( theViewManager );
4881 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4883 theActor->AddObserver( SMESH::DeleteActorEvent,
4884 myEventCallbackCommand.GetPointer(),
4888 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4889 unsigned long theEvent,
4890 void* theClientData,
4893 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4894 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4895 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4896 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4897 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4898 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4899 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4900 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4901 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4902 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4903 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4904 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4905 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4906 if( anActor == *anIter3 ) {
4907 anActorList.erase( anIter3 );
4918 void SMESHGUI::createPreferences()
4920 // General tab ------------------------------------------------------------------------
4921 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4923 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4924 setPreferenceProperty( autoUpdate, "columns", 2 );
4925 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4926 setPreferenceProperty( lim, "min", 0 );
4927 setPreferenceProperty( lim, "max", 100000000 );
4928 setPreferenceProperty( lim, "step", 1000 );
4929 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4930 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4932 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4933 setPreferenceProperty( qaGroup, "columns", 2 );
4934 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4935 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4936 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4937 setPreferenceProperty( prec, "min", 0 );
4938 setPreferenceProperty( prec, "max", 100 );
4939 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4940 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4941 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4942 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4943 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4945 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4946 setPreferenceProperty( dispgroup, "columns", 2 );
4947 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4949 modes.append( tr("MEN_WIRE") );
4950 modes.append( tr("MEN_SHADE") );
4951 modes.append( tr("MEN_NODES") );
4952 modes.append( tr("MEN_SHRINK") );
4953 QList<QVariant> indices;
4954 indices.append( 0 );
4955 indices.append( 1 );
4956 indices.append( 2 );
4957 indices.append( 3 );
4958 setPreferenceProperty( dispmode, "strings", modes );
4959 setPreferenceProperty( dispmode, "indexes", indices );
4961 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4962 setPreferenceProperty( arcgroup, "columns", 2 );
4963 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4964 QStringList quadraticModes;
4965 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4966 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4968 indices.append( 0 );
4969 indices.append( 1 );
4970 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4971 setPreferenceProperty( quadraticmode, "indexes", indices );
4973 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4974 "SMESH", "max_angle" );
4975 setPreferenceProperty( maxAngle, "min", 1 );
4976 setPreferenceProperty( maxAngle, "max", 90 );
4980 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4981 setPreferenceProperty( exportgroup, "columns", 2 );
4982 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4983 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4985 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4986 setPreferenceProperty( computeGroup, "columns", 2 );
4987 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4989 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4990 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4991 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4993 indices.append( 0 );
4994 indices.append( 1 );
4995 indices.append( 2 );
4996 setPreferenceProperty( notifyMode, "strings", modes );
4997 setPreferenceProperty( notifyMode, "indexes", indices );
4999 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5000 setPreferenceProperty( infoGroup, "columns", 2 );
5001 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5003 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5004 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5006 indices.append( 0 );
5007 indices.append( 1 );
5008 setPreferenceProperty( elemInfo, "strings", modes );
5009 setPreferenceProperty( elemInfo, "indexes", indices );
5010 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5011 setPreferenceProperty( nodesLim, "min", 0 );
5012 setPreferenceProperty( nodesLim, "max", 10000000 );
5013 setPreferenceProperty( nodesLim, "step", 10000 );
5014 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5015 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5016 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5017 setPreferenceProperty( ctrlLim, "min", 0 );
5018 setPreferenceProperty( ctrlLim, "max", 10000000 );
5019 setPreferenceProperty( ctrlLim, "step", 1000 );
5020 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5021 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5022 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5023 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5024 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5026 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5027 setPreferenceProperty( segGroup, "columns", 2 );
5028 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5029 "SMESH", "segmentation" );
5030 setPreferenceProperty( segLen, "min", 1 );
5031 setPreferenceProperty( segLen, "max", 10000000 );
5032 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5033 "SMESH", "nb_segments_per_edge" );
5034 setPreferenceProperty( nbSeg, "min", 1 );
5035 setPreferenceProperty( nbSeg, "max", 10000000 );
5037 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5038 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5039 "SMESH", "forget_mesh_on_hyp_modif" );
5042 // Quantities with individual precision settings
5043 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5044 setPreferenceProperty( precGroup, "columns", 2 );
5046 const int nbQuantities = 6;
5047 int precs[nbQuantities], ii = 0;
5048 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5049 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5050 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5051 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5052 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5053 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5054 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5055 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5056 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5057 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5058 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5059 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5061 // Set property for precision value for spinboxes
5062 for ( ii = 0; ii < nbQuantities; ii++ ){
5063 setPreferenceProperty( precs[ii], "min", -14 );
5064 setPreferenceProperty( precs[ii], "max", 14 );
5065 setPreferenceProperty( precs[ii], "precision", 2 );
5068 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5069 setPreferenceProperty( previewGroup, "columns", 2 );
5070 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5071 setPreferenceProperty( chunkSize, "min", 1 );
5072 setPreferenceProperty( chunkSize, "max", 1000 );
5073 setPreferenceProperty( chunkSize, "step", 50 );
5075 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5076 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5078 // Mesh tab ------------------------------------------------------------------------
5079 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5080 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5081 setPreferenceProperty( nodeGroup, "columns", 3 );
5083 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5085 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5087 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5088 QList<QVariant> aMarkerTypeIndicesList;
5089 QList<QVariant> aMarkerTypeIconsList;
5090 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5091 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5092 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5093 aMarkerTypeIndicesList << i;
5094 aMarkerTypeIconsList << pixmap;
5096 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5097 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5099 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5101 QList<QVariant> aMarkerScaleIndicesList;
5102 QStringList aMarkerScaleValuesList;
5103 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5104 aMarkerScaleIndicesList << i;
5105 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5107 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5108 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5110 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5111 //setPreferenceProperty( elemGroup, "columns", 2 );
5113 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5114 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5115 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5116 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5117 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5118 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5119 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5120 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5121 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5124 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5125 setPreferenceProperty( grpGroup, "columns", 2 );
5127 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5128 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5130 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5131 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5132 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5133 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5134 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5135 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5136 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5137 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5138 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5139 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5140 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5141 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5143 setPreferenceProperty( size0d, "min", 1 );
5144 setPreferenceProperty( size0d, "max", 10 );
5146 setPreferenceProperty( ballSize, "min", 1 );
5147 setPreferenceProperty( ballSize, "max", 10 );
5149 setPreferenceProperty( ballScale, "min", 1e-2 );
5150 setPreferenceProperty( ballScale, "max", 1e7 );
5151 setPreferenceProperty( ballScale, "step", 0.5 );
5153 setPreferenceProperty( elemW, "min", 1 );
5154 setPreferenceProperty( elemW, "max", 5 );
5156 setPreferenceProperty( outW, "min", 1 );
5157 setPreferenceProperty( outW, "max", 5 );
5159 setPreferenceProperty( shrink, "min", 0 );
5160 setPreferenceProperty( shrink, "max", 100 );
5162 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5163 setPreferenceProperty( numGroup, "columns", 2 );
5165 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5166 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5168 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5169 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5171 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5172 setPreferenceProperty( orientGroup, "columns", 1 );
5174 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5175 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5177 setPreferenceProperty( orientScale, "min", 0.05 );
5178 setPreferenceProperty( orientScale, "max", 0.5 );
5179 setPreferenceProperty( orientScale, "step", 0.05 );
5181 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5183 // Selection tab ------------------------------------------------------------------------
5184 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5186 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5187 setPreferenceProperty( selGroup, "columns", 2 );
5189 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5190 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5192 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5193 setPreferenceProperty( preGroup, "columns", 2 );
5195 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5197 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5198 setPreferenceProperty( precSelGroup, "columns", 2 );
5200 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5201 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5202 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5204 // Scalar Bar tab ------------------------------------------------------------------------
5205 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5206 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5207 setPreferenceProperty( fontGr, "columns", 2 );
5209 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5210 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5212 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5213 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5215 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5216 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5218 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5219 setPreferenceProperty( numcol, "min", 2 );
5220 setPreferenceProperty( numcol, "max", 256 );
5222 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5223 setPreferenceProperty( numlab, "min", 2 );
5224 setPreferenceProperty( numlab, "max", 65 );
5226 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5227 setPreferenceProperty( orientGr, "columns", 2 );
5228 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5229 QStringList orients;
5230 orients.append( tr( "SMESH_VERTICAL" ) );
5231 orients.append( tr( "SMESH_HORIZONTAL" ) );
5232 indices.clear(); indices.append( 0 ); indices.append( 1 );
5233 setPreferenceProperty( orient, "strings", orients );
5234 setPreferenceProperty( orient, "indexes", indices );
5236 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5237 setPreferenceProperty( posVSizeGr, "columns", 2 );
5238 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5239 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5240 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5241 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5242 setPreferenceProperty( xv, "step", 0.1 );
5243 setPreferenceProperty( xv, "min", 0.0 );
5244 setPreferenceProperty( xv, "max", 1.0 );
5245 setPreferenceProperty( yv, "step", 0.1 );
5246 setPreferenceProperty( yv, "min", 0.0 );
5247 setPreferenceProperty( yv, "max", 1.0 );
5248 setPreferenceProperty( wv, "step", 0.1 );
5249 setPreferenceProperty( wv, "min", 0.0 );
5250 setPreferenceProperty( wv, "max", 1.0 );
5251 setPreferenceProperty( hv, "min", 0.0 );
5252 setPreferenceProperty( hv, "max", 1.0 );
5253 setPreferenceProperty( hv, "step", 0.1 );
5255 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5256 setPreferenceProperty( posHSizeGr, "columns", 2 );
5257 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5258 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5259 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5260 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5261 setPreferenceProperty( xv, "min", 0.0 );
5262 setPreferenceProperty( xv, "max", 1.0 );
5263 setPreferenceProperty( xv, "step", 0.1 );
5264 setPreferenceProperty( xh, "min", 0.0 );
5265 setPreferenceProperty( xh, "max", 1.0 );
5266 setPreferenceProperty( xh, "step", 0.1 );
5267 setPreferenceProperty( yh, "min", 0.0 );
5268 setPreferenceProperty( yh, "max", 1.0 );
5269 setPreferenceProperty( yh, "step", 0.1 );
5270 setPreferenceProperty( wh, "min", 0.0 );
5271 setPreferenceProperty( wh, "max", 1.0 );
5272 setPreferenceProperty( wh, "step", 0.1 );
5273 setPreferenceProperty( hh, "min", 0.0 );
5274 setPreferenceProperty( hh, "max", 1.0 );
5275 setPreferenceProperty( hh, "step", 0.1 );
5277 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5278 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5279 setPreferenceProperty( distributionGr, "columns", 3 );
5281 types.append( tr( "SMESH_MONOCOLOR" ) );
5282 types.append( tr( "SMESH_MULTICOLOR" ) );
5283 indices.clear(); indices.append( 0 ); indices.append( 1 );
5284 setPreferenceProperty( coloringType, "strings", types );
5285 setPreferenceProperty( coloringType, "indexes", indices );
5286 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5290 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5292 if( sect=="SMESH" ) {
5293 float sbX1,sbY1,sbW,sbH;
5294 float aTol = 1.00000009999999;
5295 std::string aWarning;
5296 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5297 if( name=="selection_object_color" || name=="selection_element_color" ||
5298 name=="highlight_color" ||
5299 name=="selection_precision_node" || name=="selection_precision_element" ||
5300 name=="selection_precision_object")
5301 SMESH::UpdateSelectionProp( this );
5302 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5303 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5304 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5305 if(sbX1+sbW > aTol){
5306 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5309 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5310 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5313 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5314 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5315 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5316 if(sbY1+sbH > aTol){
5317 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5318 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5319 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5322 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5323 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5324 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5325 if(sbX1+sbW > aTol){
5326 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5329 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5330 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5333 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5334 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5335 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5336 if(sbY1+sbH > aTol){
5337 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5340 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5341 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5344 else if ( name == "segmentation" ) {
5345 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5346 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5348 else if ( name == "nb_segments_per_edge" ) {
5349 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5350 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5352 else if ( name == "historical_python_dump" ||
5353 name == "forget_mesh_on_hyp_modif") {
5354 QString val = aResourceMgr->stringValue( "SMESH", name );
5355 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5357 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5358 SMESH::UpdateFontProp( this );
5360 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5361 SMESH::UpdateFontProp( this );
5364 if(aWarning.size() != 0){
5365 aWarning += "The default values are applied instead.";
5366 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5367 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5368 QObject::tr(aWarning.c_str()));
5373 //================================================================================
5375 * \brief Update something in accordance with update flags
5376 * \param theFlags - update flags
5378 * Update viewer or/and object browser etc. in accordance with update flags ( see
5379 * LightApp_UpdateFlags enumeration ).
5381 //================================================================================
5382 void SMESHGUI::update( const int flags )
5384 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5385 SMESH::UpdateView();
5387 SalomeApp_Module::update( flags );
5390 //================================================================================
5392 * \brief Set default selection mode
5394 * SLOT called when operation commited. Sets default selection mode
5396 //================================================================================
5397 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5399 SVTK_ViewWindow* vtkWnd =
5400 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5402 vtkWnd->SetSelectionMode( ActorSelection );
5405 //================================================================================
5407 * \brief Set default selection mode
5409 * SLOT called when operation aborted. Sets default selection mode
5411 //================================================================================
5412 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5414 SVTK_ViewWindow* vtkWnd =
5415 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5417 vtkWnd->SetSelectionMode( ActorSelection );
5420 //================================================================================
5422 * \brief Creates operation with given identifier
5423 * \param id - identifier of operation to be started
5424 * \return Pointer on created operation or NULL if operation is not created
5426 * Virtual method redefined from the base class creates operation with given id.
5427 * It is called called automatically from startOperation method of base class.
5429 //================================================================================
5430 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5432 LightApp_Operation* op = 0;
5433 // to do : create operation here
5436 case SMESHOp::OpConvertMeshToQuadratic:
5437 op = new SMESHGUI_ConvToQuadOp();
5439 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5440 op = new SMESHGUI_Make2DFrom3DOp();
5442 case SMESHOp::OpReorientFaces:
5443 op = new SMESHGUI_ReorientFacesOp();
5445 case SMESHOp::OpCreateMesh:
5446 op = new SMESHGUI_MeshOp( true, true );
5448 case SMESHOp::OpCreateSubMesh:
5449 op = new SMESHGUI_MeshOp( true, false );
5451 case SMESHOp::OpEditMeshOrSubMesh:
5452 op = new SMESHGUI_MeshOp( false );
5454 case SMESHOp::OpCompute:
5455 op = new SMESHGUI_ComputeOp();
5457 case SMESHOp::OpPreCompute:
5458 op = new SMESHGUI_PrecomputeOp();
5460 case SMESHOp::OpEvaluate:
5461 op = new SMESHGUI_EvaluateOp();
5463 case SMESHOp::OpMeshOrder:
5464 op = new SMESHGUI_MeshOrderOp();
5466 case SMESHOp::OpCreateGeometryGroup:
5467 op = new SMESHGUI_GroupOnShapeOp();
5469 case SMESHOp::OpFindElementByPoint:
5470 op = new SMESHGUI_FindElemByPointOp();
5472 case SMESHOp::OpMoveNode: // Make mesh pass through point
5473 op = new SMESHGUI_MakeNodeAtPointOp();
5475 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5476 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5483 op = SalomeApp_Module::createOperation( id );
5487 //================================================================================
5489 * \brief Stops current operations and starts a given one
5490 * \param id - The id of the operation to start
5492 //================================================================================
5494 void SMESHGUI::switchToOperation(int id)
5496 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5497 activeStudy()->abortAllOperations();
5498 startOperation( id );
5501 LightApp_Displayer* SMESHGUI::displayer()
5504 myDisplayer = new SMESHGUI_Displayer( getApp() );
5508 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5511 int aTolerance = 64;
5512 int anIterations = 0;
5518 if( anIterations % aPeriod == 0 )
5521 if( aTolerance < 1 )
5525 aHue = (int)( 360.0 * rand() / RAND_MAX );
5528 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5529 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5530 for( ; it != itEnd; ++it )
5532 SALOMEDS::Color anAutoColor = *it;
5533 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5536 aQColor.getHsv( &h, &s, &v );
5537 if( abs( h - aHue ) < aTolerance )
5549 aColor.setHsv( aHue, 255, 255 );
5551 SALOMEDS::Color aSColor;
5552 aSColor.R = aColor.redF();
5553 aSColor.G = aColor.greenF();
5554 aSColor.B = aColor.blueF();
5559 const char* gSeparator = "_"; // character used to separate parameter names
5560 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5561 const char* gPathSep = "|"; // character used to separate paths
5564 * \brief Store visual parameters
5566 * This method is called just before the study document is saved.
5567 * Store visual parameters in AttributeParameter attribue(s)
5569 void SMESHGUI::storeVisualParameters (int savePoint)
5572 Kernel_Utils::Localizer loc;
5574 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5575 if (!appStudy || !appStudy->studyDS())
5577 _PTR(Study) studyDS = appStudy->studyDS();
5579 // componentName is used for encoding of entries when storing them in IParameters
5580 std::string componentName = myComponentSMESH->ComponentDataType();
5581 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5582 //if (!aSComponent) return;
5585 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5586 componentName.c_str(),
5588 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5590 // store map of custom markers
5591 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5592 if( !aMarkerMap.empty() )
5594 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5595 for( ; anIter != aMarkerMap.end(); anIter++ )
5597 int anId = anIter->first;
5598 VTK::MarkerData aMarkerData = anIter->second;
5599 std::string aMarkerFileName = aMarkerData.first;
5600 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5601 if( aMarkerTexture.size() < 3 )
5602 continue; // should contain at least width, height and the first value
5604 QString aPropertyName( "texture" );
5605 aPropertyName += gSeparator;
5606 aPropertyName += QString::number( anId );
5608 QString aPropertyValue = aMarkerFileName.c_str();
5609 aPropertyValue += gPathSep;
5611 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5612 ushort aWidth = *aTextureIter++;
5613 ushort aHeight = *aTextureIter++;
5614 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5615 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5616 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5617 aPropertyValue += QString::number( *aTextureIter );
5619 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5623 // viewers counters are used for storing view_numbers in IParameters
5626 // main cycle to store parameters of displayed objects
5627 QList<SUIT_ViewManager*> lst;
5628 QList<SUIT_ViewManager*>::Iterator it;
5629 getApp()->viewManagers(lst);
5630 for (it = lst.begin(); it != lst.end(); it++)
5632 SUIT_ViewManager* vman = *it;
5633 QString vType = vman->getType();
5635 // saving VTK actors properties
5636 if (vType == SVTK_Viewer::Type())
5638 // store the clipping planes attached to the view manager
5639 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5640 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5641 if( anIter != myClippingPlaneInfoMap.end() )
5642 aClippingPlaneInfoList = anIter->second;
5644 if( !aClippingPlaneInfoList.empty() ) {
5645 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5646 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5648 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5649 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5651 QString aPropertyName( "ClippingPlane" );
5652 aPropertyName += gSeparator;
5653 aPropertyName += QString::number( vtkViewers );
5654 aPropertyName += gSeparator;
5655 aPropertyName += QString::number( anId );
5657 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5658 aPropertyValue += gDigitsSep;
5659 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5660 aPropertyValue += gDigitsSep;
5661 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5662 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5663 aPropertyValue += gDigitsSep;
5664 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5665 aPropertyValue += gDigitsSep;
5666 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5667 aPropertyValue += gDigitsSep;
5668 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5669 aPropertyValue += gDigitsSep;
5670 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5671 aPropertyValue += gDigitsSep;
5672 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5673 aPropertyValue += gDigitsSep;
5674 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5676 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5677 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5678 aPropertyValue += gDigitsSep;
5679 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5680 aPropertyValue += gDigitsSep;
5681 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5682 aPropertyValue += gDigitsSep;
5683 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5686 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5690 QVector<SUIT_ViewWindow*> views = vman->getViews();
5691 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5693 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5695 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5696 vtkActorCollection* allActors = aCopy.GetActors();
5697 allActors->InitTraversal();
5698 while (vtkActor* actor = allActors->GetNextActor())
5700 if (actor->GetVisibility()) // store only visible actors
5702 SMESH_Actor* aSmeshActor = 0;
5703 if (actor->IsA("SMESH_Actor"))
5704 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5705 if (aSmeshActor && aSmeshActor->hasIO())
5707 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5710 // entry is "encoded" = it does NOT contain component adress,
5711 // since it is a subject to change on next component loading
5712 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5714 std::string param, vtkParam = vType.toLatin1().data();
5715 vtkParam += gSeparator;
5716 vtkParam += QString::number(vtkViewers).toLatin1().data();
5717 vtkParam += gSeparator;
5720 param = vtkParam + "Visibility";
5721 ip->setParameter(entry, param, "On");
5724 param = vtkParam + "Representation";
5725 ip->setParameter(entry, param, QString::number
5726 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5729 param = vtkParam + "IsShrunk";
5730 ip->setParameter(entry, param, QString::number
5731 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5733 // Displayed entities
5734 unsigned int aMode = aSmeshActor->GetEntityMode();
5735 bool isE = aMode & SMESH_Actor::eEdges;
5736 bool isF = aMode & SMESH_Actor::eFaces;
5737 bool isV = aMode & SMESH_Actor::eVolumes;
5738 bool is0d = aMode & SMESH_Actor::e0DElements;
5739 bool isB = aMode & SMESH_Actor::eBallElem;
5741 QString modeStr ("e");
5742 modeStr += gDigitsSep; modeStr += QString::number(isE);
5743 modeStr += gDigitsSep; modeStr += "f";
5744 modeStr += gDigitsSep; modeStr += QString::number(isF);
5745 modeStr += gDigitsSep; modeStr += "v";
5746 modeStr += gDigitsSep; modeStr += QString::number(isV);
5747 modeStr += gDigitsSep; modeStr += "0d";
5748 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5749 modeStr += gDigitsSep; modeStr += "b";
5750 modeStr += gDigitsSep; modeStr += QString::number(isB);
5752 param = vtkParam + "Entities";
5753 ip->setParameter(entry, param, modeStr.toLatin1().data());
5759 aSmeshActor->GetSufaceColor(r, g, b, delta);
5760 QStringList colorStr;
5761 colorStr << "surface";
5762 colorStr << QString::number(r);
5763 colorStr << QString::number(g);
5764 colorStr << QString::number(b);
5766 colorStr << "backsurface";
5767 colorStr << QString::number(delta);
5769 aSmeshActor->GetVolumeColor(r, g, b, delta);
5770 colorStr << "volume";
5771 colorStr << QString::number(r);
5772 colorStr << QString::number(g);
5773 colorStr << QString::number(b);
5774 colorStr << QString::number(delta);
5776 aSmeshActor->GetEdgeColor(r, g, b);
5778 colorStr << QString::number(r);
5779 colorStr << QString::number(g);
5780 colorStr << QString::number(b);
5782 aSmeshActor->GetNodeColor(r, g, b);
5784 colorStr << QString::number(r);
5785 colorStr << QString::number(g);
5786 colorStr << QString::number(b);
5788 aSmeshActor->GetOutlineColor(r, g, b);
5789 colorStr << "outline";
5790 colorStr << QString::number(r);
5791 colorStr << QString::number(g);
5792 colorStr << QString::number(b);
5794 aSmeshActor->Get0DColor(r, g, b);
5795 colorStr << "elem0d";
5796 colorStr << QString::number(r);
5797 colorStr << QString::number(g);
5798 colorStr << QString::number(b);
5800 aSmeshActor->GetBallColor(r, g, b);
5802 colorStr << QString::number(r);
5803 colorStr << QString::number(g);
5804 colorStr << QString::number(b);
5806 aSmeshActor->GetFacesOrientationColor(r, g, b);
5807 colorStr << "orientation";
5808 colorStr << QString::number(r);
5809 colorStr << QString::number(g);
5810 colorStr << QString::number(b);
5812 param = vtkParam + "Colors";
5813 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5816 QStringList sizeStr;
5818 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5819 sizeStr << "outline";
5820 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5821 sizeStr << "elem0d";
5822 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5824 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5825 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5826 sizeStr << "shrink";
5827 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5828 sizeStr << "orientation";
5829 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5830 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5832 param = vtkParam + "Sizes";
5833 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5838 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5839 if( aMarkerType == VTK::MT_USER ) {
5840 markerStr += "custom";
5841 markerStr += gDigitsSep;
5842 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5846 markerStr += gDigitsSep;
5847 markerStr += QString::number( (int)aMarkerType );
5848 markerStr += gDigitsSep;
5849 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5852 param = vtkParam + "PointMarker";
5853 ip->setParameter(entry, param, markerStr.toLatin1().data());
5856 param = vtkParam + "Opacity";
5857 ip->setParameter(entry, param,
5858 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5861 param = vtkParam + "ClippingPlane";
5863 if( !aClippingPlaneInfoList.empty() ) {
5864 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5865 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5867 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5868 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5869 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5870 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5871 if( aSmeshActor == *anIter2 ) {
5872 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5873 QString::number( anId ).toLatin1().constData() );
5880 ip->setParameter( entry, param, "Off" );
5881 } // if (io->hasEntry())
5882 } // SMESH_Actor && hasIO
5884 } // while.. actors traversal
5888 } // if (SVTK view model)
5889 } // for (viewManagers)
5892 // data structures for clipping planes processing
5896 bool isOpenGLClipping;
5897 vtkIdType RelativeOrientation;
5900 int AbsoluteOrientation;
5901 double X, Y, Z, Dx, Dy, Dz;
5903 typedef std::list<TPlaneData> TPlaneDataList;
5904 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5906 typedef std::list<vtkActor*> TActorList;
5909 TActorList ActorList;
5910 SUIT_ViewManager* ViewManager;
5912 typedef std::list<TPlaneInfo> TPlaneInfoList;
5913 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5916 * \brief Restore visual parameters
5918 * This method is called after the study document is opened.
5919 * Restore visual parameters from AttributeParameter attribue(s)
5921 void SMESHGUI::restoreVisualParameters (int savePoint)
5924 Kernel_Utils::Localizer loc;
5926 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5927 if (!appStudy || !appStudy->studyDS())
5929 _PTR(Study) studyDS = appStudy->studyDS();
5931 // componentName is used for encoding of entries when storing them in IParameters
5932 std::string componentName = myComponentSMESH->ComponentDataType();
5933 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5934 //if (!aSComponent) return;
5937 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5938 componentName.c_str(),
5940 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5942 // restore map of custom markers and map of clipping planes
5943 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5944 TPlaneDataMap aPlaneDataMap;
5946 std::vector<std::string> properties = ip->getProperties();
5947 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5949 std::string property = *propIt;
5950 QString aPropertyName( property.c_str() );
5951 QString aPropertyValue( ip->getProperty( property ).c_str() );
5953 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5954 if( aPropertyNameList.isEmpty() )
5957 QString aPropertyType = aPropertyNameList[0];
5958 if( aPropertyType == "texture" )
5960 if( aPropertyNameList.size() != 2 )
5964 int anId = aPropertyNameList[1].toInt( &ok );
5965 if( !ok || anId < 1 )
5968 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5969 if( aPropertyValueList.size() != 2 )
5972 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5973 QString aMarkerTextureString = aPropertyValueList[1];
5974 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5975 if( aMarkerTextureStringList.size() != 3 )
5979 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5984 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5988 VTK::MarkerTexture aMarkerTexture;
5989 aMarkerTexture.push_back( aWidth );
5990 aMarkerTexture.push_back( aHeight );
5992 QString aMarkerTextureData = aMarkerTextureStringList[2];
5993 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5995 QChar aChar = aMarkerTextureData.at( i );
5996 if( aChar.isDigit() )
5997 aMarkerTexture.push_back( aChar.digitValue() );
6000 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6002 else if( aPropertyType == "ClippingPlane" )
6004 if( aPropertyNameList.size() != 3 )
6008 int aViewId = aPropertyNameList[1].toInt( &ok );
6009 if( !ok || aViewId < 0 )
6013 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6014 if( !ok || aClippingPlaneId < 0 )
6017 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6018 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6021 TPlaneData aPlaneData;
6022 aPlaneData.Id = aClippingPlaneId;
6025 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6030 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6034 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6037 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6042 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6047 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6052 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6057 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6062 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6067 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6071 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6073 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6078 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6083 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6088 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6093 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6094 aPlaneDataList.push_back( aPlaneData );
6098 TPlaneInfoMap aPlaneInfoMap;
6100 std::vector<std::string> entries = ip->getEntries();
6102 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6104 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6105 QString entry (ip->decodeEntry(*entIt).c_str());
6107 // Check that the entry corresponds to a real object in the Study
6108 // as the object may be deleted or modified after the visual state is saved.
6109 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6110 if (!so) continue; //Skip the not existent entry
6112 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6113 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6115 std::vector<std::string>::iterator namesIt = paramNames.begin();
6116 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6118 // actors are stored in a map after displaying of them for
6119 // quicker access in the future: map < viewID to actor >
6120 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6122 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6124 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6125 // '_' is used as separator and should not be used in viewer type or parameter names.
6126 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6127 if (lst.size() != 3)
6130 QString viewerTypStr = lst[0];
6131 QString viewIndexStr = lst[1];
6132 QString paramNameStr = lst[2];
6135 int viewIndex = viewIndexStr.toUInt(&ok);
6136 if (!ok) // bad conversion of view index to integer
6140 if (viewerTypStr == SVTK_Viewer::Type())
6142 SMESH_Actor* aSmeshActor = 0;
6143 if (vtkActors.IsBound(viewIndex))
6144 aSmeshActor = vtkActors.Find(viewIndex);
6146 QList<SUIT_ViewManager*> lst;
6147 getApp()->viewManagers(viewerTypStr, lst);
6149 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6150 SUIT_ViewManager* vman = NULL;
6151 if (viewIndex >= 0 && viewIndex < lst.count())
6152 vman = lst.at(viewIndex);
6154 if (paramNameStr == "Visibility")
6156 if (!aSmeshActor && displayer() && vman)
6158 SUIT_ViewModel* vmodel = vman->getViewModel();
6159 // SVTK view model can be casted to SALOME_View
6160 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6162 // store displayed actor in a temporary map for quicker
6163 // access later when restoring other parameters
6164 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6165 vtkRenderer* Renderer = vtkView->getRenderer();
6166 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6167 vtkActorCollection* theActors = aCopy.GetActors();
6168 theActors->InitTraversal();
6169 bool isFound = false;
6170 vtkActor *ac = theActors->GetNextActor();
6171 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6172 if (ac->IsA("SMESH_Actor")) {
6173 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6174 if (aGeomAc->hasIO()) {
6175 Handle(SALOME_InteractiveObject) io =
6176 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6177 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6179 vtkActors.Bind(viewIndex, aGeomAc);
6185 } // if (paramNameStr == "Visibility")
6188 // the rest properties "work" with SMESH_Actor
6191 QString val ((*valuesIt).c_str());
6194 if (paramNameStr == "Representation") {
6195 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6198 else if (paramNameStr == "IsShrunk") {
6200 if (!aSmeshActor->IsShrunk())
6201 aSmeshActor->SetShrink();
6204 if (aSmeshActor->IsShrunk())
6205 aSmeshActor->UnShrink();
6208 // Displayed entities
6209 else if (paramNameStr == "Entities") {
6210 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6211 int aEntityMode = SMESH_Actor::eAllEntity;
6212 for ( int i = 0; i < mode.count(); i+=2 ) {
6213 if ( i < mode.count()-1 ) {
6214 QString type = mode[i];
6215 bool val = mode[i+1].toInt();
6216 if ( type == "e" && !val )
6217 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6218 else if ( type == "f" && !val )
6219 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6220 else if ( type == "v" && !val )
6221 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6222 else if ( type == "0d" && !val )
6223 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6224 else if ( type == "b" && !val )
6225 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6228 aSmeshActor->SetEntityMode( aEntityMode );
6231 else if (paramNameStr == "Colors") {
6232 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6239 QColor outlineColor;
6240 QColor orientationColor;
6246 // below lines are required to get default values for delta coefficients
6247 // of backface color for faces and color of reversed volumes
6248 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6249 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6250 for ( int i = 0; i < colors.count(); i++ ) {
6251 QString type = colors[i];
6252 if ( type == "surface" ) {
6253 // face color is set by 3 values r:g:b, where
6254 // - r,g,b - is rgb color components
6255 if ( i+1 >= colors.count() ) break; // format error
6256 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6257 if ( i+2 >= colors.count() ) break; // format error
6258 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6259 if ( i+3 >= colors.count() ) break; // format error
6260 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6261 faceColor.setRgbF( r, g, b );
6264 else if ( type == "backsurface" ) {
6265 // backface color can be defined in several ways
6266 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6267 // - in latest versions, it is set as delta coefficient
6268 bool rgbOk = false, deltaOk;
6269 if ( i+1 >= colors.count() ) break; // format error
6270 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6271 int delta = colors[i+1].toInt( &deltaOk );
6273 if ( i+1 < colors.count() ) // index is shifted to 1
6274 g = colors[i+1].toDouble( &rgbOk );
6275 if ( rgbOk ) i++; // shift index
6276 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6277 b = colors[i+1].toDouble( &rgbOk );
6279 // - as currently there's no way to set directly backsurface color as it was before,
6280 // we ignore old dump where r,g,b triple was set
6281 // - also we check that delta parameter is set properly
6282 if ( !rgbOk && deltaOk )
6285 else if ( type == "volume" ) {
6286 // volume color is set by 4 values r:g:b:delta, where
6287 // - r,g,b - is a normal volume rgb color components
6288 // - delta - is a reversed volume color delta coefficient
6289 if ( i+1 >= colors.count() ) break; // format error
6290 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6291 if ( i+2 >= colors.count() ) break; // format error
6292 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6293 if ( i+3 >= colors.count() ) break; // format error
6294 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6295 if ( i+4 >= colors.count() ) break; // format error
6296 int delta = colors[i+4].toInt( &bOk );
6297 if ( !bOk ) break; // format error
6298 volumeColor.setRgbF( r, g, b );
6302 else if ( type == "edge" ) {
6303 // edge color is set by 3 values r:g:b, where
6304 // - r,g,b - is rgb color components
6305 if ( i+1 >= colors.count() ) break; // format error
6306 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6307 if ( i+2 >= colors.count() ) break; // format error
6308 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6309 if ( i+3 >= colors.count() ) break; // format error
6310 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6311 edgeColor.setRgbF( r, g, b );
6314 else if ( type == "node" ) {
6315 // node color is set by 3 values r:g:b, where
6316 // - r,g,b - is rgb color components
6317 if ( i+1 >= colors.count() ) break; // format error
6318 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6319 if ( i+2 >= colors.count() ) break; // format error
6320 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6321 if ( i+3 >= colors.count() ) break; // format error
6322 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6323 nodeColor.setRgbF( r, g, b );
6326 else if ( type == "elem0d" ) {
6327 // 0d element color is set by 3 values r:g:b, where
6328 // - r,g,b - is rgb color components
6329 if ( i+1 >= colors.count() ) break; // format error
6330 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6331 if ( i+2 >= colors.count() ) break; // format error
6332 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6333 if ( i+3 >= colors.count() ) break; // format error
6334 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6335 elem0dColor.setRgbF( r, g, b );
6338 else if ( type == "ball" ) {
6339 // ball color is set by 3 values r:g:b, where
6340 // - r,g,b - is rgb color components
6341 if ( i+1 >= colors.count() ) break; // format error
6342 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6343 if ( i+2 >= colors.count() ) break; // format error
6344 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6345 if ( i+3 >= colors.count() ) break; // format error
6346 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6347 ballColor.setRgbF( r, g, b );
6350 else if ( type == "outline" ) {
6351 // outline color is set by 3 values r:g:b, where
6352 // - r,g,b - is rgb color components
6353 if ( i+1 >= colors.count() ) break; // format error
6354 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6355 if ( i+2 >= colors.count() ) break; // format error
6356 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6357 if ( i+3 >= colors.count() ) break; // format error
6358 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6359 outlineColor.setRgbF( r, g, b );
6362 else if ( type == "orientation" ) {
6363 // orientation color is set by 3 values r:g:b, where
6364 // - r,g,b - is rgb color components
6365 if ( i+1 >= colors.count() ) break; // format error
6366 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6367 if ( i+2 >= colors.count() ) break; // format error
6368 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6369 if ( i+3 >= colors.count() ) break; // format error
6370 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6371 orientationColor.setRgbF( r, g, b );
6376 if ( nodeColor.isValid() )
6377 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6379 if ( edgeColor.isValid() )
6380 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6382 if ( faceColor.isValid() )
6383 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6385 if ( volumeColor.isValid() )
6386 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6387 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6388 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6390 if ( elem0dColor.isValid() )
6391 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6393 if ( ballColor.isValid() )
6394 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6396 if ( outlineColor.isValid() )
6397 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6398 // orientation color
6399 if ( orientationColor.isValid() )
6400 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6403 else if (paramNameStr == "Sizes") {
6404 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6407 int outlineWidth = -1;
6408 int elem0dSize = -1;
6410 double ballScale = -1.0;
6411 double shrinkSize = -1;
6412 double orientationSize = -1;
6413 bool orientation3d = false;
6414 for ( int i = 0; i < sizes.count(); i++ ) {
6415 QString type = sizes[i];
6416 if ( type == "line" ) {
6417 // line (wireframe) width is given as single integer value
6418 if ( i+1 >= sizes.count() ) break; // format error
6419 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6423 if ( type == "outline" ) {
6424 // outline width is given as single integer value
6425 if ( i+1 >= sizes.count() ) break; // format error
6426 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6430 else if ( type == "elem0d" ) {
6431 // 0d element size is given as single integer value
6432 if ( i+1 >= sizes.count() ) break; // format error
6433 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6437 else if ( type == "ball" ) {
6438 // balls are specified by two values: size:scale, where
6439 // - size - is a integer value specifying size
6440 // - scale - is a double value specifying scale factor
6441 if ( i+1 >= sizes.count() ) break; // format error
6442 int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6443 if ( i+2 >= sizes.count() ) break; // format error
6444 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6449 else if ( type == "shrink" ) {
6450 // shrink factor is given as single floating point value
6451 if ( i+1 >= sizes.count() ) break; // format error
6452 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6456 else if ( type == "orientation" ) {
6457 // orientation vectors are specified by two values size:3d, where
6458 // - size - is a floating point value specifying scale factor
6459 // - 3d - is a boolean
6460 if ( i+1 >= sizes.count() ) break; // format error
6461 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6462 if ( i+2 >= sizes.count() ) break; // format error
6463 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6464 orientationSize = v1;
6465 orientation3d = (bool)v2;
6469 // line (wireframe) width
6470 if ( lineWidth > 0 )
6471 aSmeshActor->SetLineWidth( lineWidth );
6473 if ( outlineWidth > 0 )
6474 aSmeshActor->SetOutlineWidth( outlineWidth );
6475 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6476 aSmeshActor->SetOutlineWidth( lineWidth );
6478 if ( elem0dSize > 0 )
6479 aSmeshActor->Set0DSize( elem0dSize );
6482 aSmeshActor->SetBallSize( ballSize );
6484 if ( ballScale > 0.0 )
6485 aSmeshActor->SetBallScale( ballScale );
6487 if ( shrinkSize > 0 )
6488 aSmeshActor->SetShrinkFactor( shrinkSize );
6489 // orientation vectors
6490 if ( orientationSize > 0 ) {
6491 aSmeshActor->SetFacesOrientationScale( orientationSize );
6492 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6496 else if (paramNameStr == "PointMarker") {
6497 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6498 if( data.count() >= 2 ) {
6500 int aParam1 = data[1].toInt( &ok );
6502 if( data[0] == "std" && data.count() == 3 ) {
6503 int aParam2 = data[2].toInt( &ok );
6504 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6506 else if( data[0] == "custom" ) {
6507 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6508 if( markerIt != aMarkerMap.end() ) {
6509 VTK::MarkerData aMarkerData = markerIt->second;
6510 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6517 else if (paramNameStr == "Opacity") {
6518 aSmeshActor->SetOpacity(val.toFloat());
6521 else if (paramNameStr.startsWith("ClippingPlane")) {
6522 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6523 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6524 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6525 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6526 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6527 // new format - val looks like "Off" or "0" (plane id)
6528 // (note: in new format "Off" value is used only for consistency,
6529 // so it is processed together with values in old format)
6530 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6531 if( anIsOldFormat ) {
6532 if (paramNameStr == "ClippingPlane1" || val == "Off")
6533 aSmeshActor->RemoveAllClippingPlanes();
6535 QList<SUIT_ViewManager*> lst;
6536 getApp()->viewManagers(viewerTypStr, lst);
6537 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6538 if (viewIndex >= 0 && viewIndex < lst.count()) {
6539 SUIT_ViewManager* vman = lst.at(viewIndex);
6540 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6542 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6544 SMESH::TActorList anActorList;
6545 anActorList.push_back( aSmeshActor );
6546 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6547 aPlane->myViewWindow = vtkView;
6548 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6549 aPlane->PlaneMode = aMode;
6550 bool isOpenGLClipping = ( bool )vals[1].toInt();
6551 aPlane->IsOpenGLClipping = isOpenGLClipping;
6552 if ( aMode == SMESH::Absolute ) {
6553 aPlane->myAbsoluteOrientation = vals[2].toInt();
6554 aPlane->X = vals[3].toFloat();
6555 aPlane->Y = vals[4].toFloat();
6556 aPlane->Z = vals[5].toFloat();
6557 aPlane->Dx = vals[6].toFloat();
6558 aPlane->Dy = vals[7].toFloat();
6559 aPlane->Dz = vals[8].toFloat();
6561 else if ( aMode == SMESH::Relative ) {
6562 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6563 aPlane->myDistance = vals[3].toFloat();
6564 aPlane->myAngle[0] = vals[4].toFloat();
6565 aPlane->myAngle[1] = vals[5].toFloat();
6569 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6570 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6571 aClippingPlaneInfo.Plane = aPlane;
6572 aClippingPlaneInfo.ActorList = anActorList;
6573 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6581 int aPlaneId = val.toInt( &ok );
6582 if( ok && aPlaneId >= 0 ) {
6583 bool anIsDefinedPlane = false;
6584 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6585 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6586 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6587 TPlaneInfo& aPlaneInfo = *anIter;
6588 if( aPlaneInfo.PlaneId == aPlaneId ) {
6589 aPlaneInfo.ActorList.push_back( aSmeshActor );
6590 anIsDefinedPlane = true;
6594 if( !anIsDefinedPlane ) {
6595 TPlaneInfo aPlaneInfo;
6596 aPlaneInfo.PlaneId = aPlaneId;
6597 aPlaneInfo.ActorList.push_back( aSmeshActor );
6598 aPlaneInfo.ViewManager = vman;
6600 // to make the list sorted by plane id
6601 anIter = aPlaneInfoList.begin();
6602 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6603 const TPlaneInfo& aPlaneInfoRef = *anIter;
6604 if( aPlaneInfoRef.PlaneId > aPlaneId )
6607 aPlaneInfoList.insert( anIter, aPlaneInfo );
6612 } // if (aSmeshActor)
6613 } // other parameters than Visibility
6615 } // for names/parameters iterator
6616 } // for entries iterator
6618 // take into account planes with empty list of actors referred to them
6619 QList<SUIT_ViewManager*> aVMList;
6620 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6622 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6623 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6624 int aViewId = aPlaneDataIter->first;
6625 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6626 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6628 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6630 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6631 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6632 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6633 const TPlaneData& aPlaneData = *anIter2;
6634 int aPlaneId = aPlaneData.Id;
6636 bool anIsFound = false;
6637 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6638 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6639 const TPlaneInfo& aPlaneInfo = *anIter3;
6640 if( aPlaneInfo.PlaneId == aPlaneId ) {
6647 TPlaneInfo aPlaneInfo; // ActorList field is empty
6648 aPlaneInfo.PlaneId = aPlaneId;
6649 aPlaneInfo.ViewManager = aViewManager;
6651 // to make the list sorted by plane id
6652 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6653 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6654 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6655 if( aPlaneInfoRef.PlaneId > aPlaneId )
6658 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6664 // add clipping planes to actors according to the restored parameters
6665 // and update the clipping plane map
6666 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6667 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6668 int aViewId = anIter1->first;
6669 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6671 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6672 if( anIter2 == aPlaneDataMap.end() )
6674 const TPlaneDataList& aPlaneDataList = anIter2->second;
6676 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6677 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6678 const TPlaneInfo& aPlaneInfo = *anIter3;
6679 int aPlaneId = aPlaneInfo.PlaneId;
6680 const TActorList& anActorList = aPlaneInfo.ActorList;
6681 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6685 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6689 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6691 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6692 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6693 const TPlaneData& aPlaneData = *anIter4;
6694 if( aPlaneData.Id == aPlaneId ) {
6695 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6696 aPlane->myViewWindow = aViewWindow;
6697 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6698 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6699 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6700 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6701 aPlane->X = aPlaneData.X;
6702 aPlane->Y = aPlaneData.Y;
6703 aPlane->Z = aPlaneData.Z;
6704 aPlane->Dx = aPlaneData.Dx;
6705 aPlane->Dy = aPlaneData.Dy;
6706 aPlane->Dz = aPlaneData.Dz;
6708 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6709 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6710 aPlane->myDistance = aPlaneData.Distance;
6711 aPlane->myAngle[0] = aPlaneData.Angle[0];
6712 aPlane->myAngle[1] = aPlaneData.Angle[1];
6715 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6716 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6717 aClippingPlaneInfo.Plane = aPlane;
6718 aClippingPlaneInfo.ActorList = anActorList;
6719 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6730 // update all VTK views
6731 QList<SUIT_ViewManager*> lst;
6732 getApp()->viewManagers(lst);
6733 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6734 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6735 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6736 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6737 // set OpenGL clipping planes
6738 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6739 vtkActorCollection* anAllActors = aCopy.GetActors();
6740 anAllActors->InitTraversal();
6741 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6742 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6743 anActor->SetOpenGLClippingPlane();
6745 vtkView->getRenderer()->ResetCameraClippingRange();
6752 \brief Adds preferences for dfont of VTK viewer
6754 \param pIf group identifier
6755 \param param parameter
6756 \return identifier of preferences
6758 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6760 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6762 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6765 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6766 fam.append( tr( "SMESH_FONT_COURIER" ) );
6767 fam.append( tr( "SMESH_FONT_TIMES" ) );
6769 setPreferenceProperty( tfont, "fonts", fam );
6771 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6772 if ( needSize ) f = f | QtxFontEdit::Size;
6773 setPreferenceProperty( tfont, "features", f );
6779 \brief Actions after hypothesis edition
6780 Updates object browser after hypothesis edition
6782 void SMESHGUI::onHypothesisEdit( int result )
6785 SMESHGUI::Modified();
6786 updateObjBrowser( true );
6791 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6792 \param pview view being closed
6794 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6795 #ifndef DISABLE_PLOT2DVIEWER
6796 //Crear all Plot2d Viewers if need.
6797 SMESH::ClearPlot2Viewers(pview);
6801 void SMESHGUI::message( const QString& msg )
6804 QStringList data = msg.split("/");
6805 if ( data.count() > 0 ) {
6806 if ( data.first() == "mesh_loading" ) {
6808 QString entry = data.count() > 1 ? data[1] : QString();
6809 if ( entry.isEmpty() )
6812 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6814 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6817 name = SMESH::fromUtf8(obj->GetName());
6818 if ( name.isEmpty() )
6821 if ( data.last() == "stop" )
6822 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6824 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6825 QApplication::processEvents();
6831 \brief Connects or disconnects signals about activating and cloning view on the module slots
6832 \param pview view which is connected/disconnected
6834 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6838 SUIT_ViewManager* viewMgr = pview->getViewManager();
6840 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6841 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6843 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6844 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6849 \brief Return \c true if object can be renamed
6851 bool SMESHGUI::renameAllowed( const QString& entry) const {
6852 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6856 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6860 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6865 if(appStudy->isComponent(entry) || obj->isReference())
6868 // check type to prevent renaming of inappropriate objects
6869 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6870 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6871 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6872 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6873 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6874 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6881 Rename object by entry.
6882 \param entry entry of the object
6883 \param name new name of the object
6884 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6886 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6888 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6892 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6897 _PTR(Study) aStudy = appStudy->studyDS();
6902 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6904 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6909 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6910 _PTR(GenericAttribute) anAttr;
6911 _PTR(AttributeName) aName;
6913 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6915 // check type to prevent renaming of inappropriate objects
6916 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6917 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6918 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6919 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6920 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6921 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6922 if ( !name.isEmpty() ) {
6923 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6925 // update name of group object and its actor
6926 Handle(SALOME_InteractiveObject) IObject =
6927 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6929 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6930 if( !aGroupObject->_is_nil() ) {
6931 aGroupObject->SetName( qPrintable(name) );
6932 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6933 anActor->setName( qPrintable(name) );
6943 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6945 static QList<QColor> colors;
6947 if ( colors.isEmpty() ) {
6949 for (int s = 0; s < 2 ; s++)
6951 for (int v = 100; v >= 40; v = v - 20)
6953 for (int h = 0; h < 359 ; h = h + 60)
6955 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6960 static int currentColor = randomize( colors.size() );
6962 SALOMEDS::Color color;
6963 color.R = (double)colors[currentColor].red() / 255.0;
6964 color.G = (double)colors[currentColor].green() / 255.0;
6965 color.B = (double)colors[currentColor].blue() / 255.0;
6967 currentColor = (currentColor+1) % colors.count();